separate compiler and plugin tests
This commit is contained in:
Dmitry Jemerov
@@ -1,38 +0,0 @@
|
||||
== foo ==
|
||||
fun foo() {
|
||||
val a = Array<Int>
|
||||
3
|
||||
a[10] = 4
|
||||
2
|
||||
a[10]
|
||||
100
|
||||
a[10] += 1
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
r(Array)
|
||||
r(Array<Int>)
|
||||
w(a)
|
||||
r(3)
|
||||
r(4)
|
||||
r(10)
|
||||
r(a)
|
||||
r(=)
|
||||
w(a[10])
|
||||
r(2)
|
||||
r(10)
|
||||
r(a)
|
||||
r(a[10])
|
||||
r(100)
|
||||
r(10)
|
||||
r(a)
|
||||
r(a[10])
|
||||
r(1)
|
||||
r(+=)
|
||||
w(a[10])
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1,9 +0,0 @@
|
||||
fun foo() {
|
||||
val a = Array<Int>
|
||||
3
|
||||
a[10] = 4
|
||||
2
|
||||
a[10]
|
||||
100
|
||||
a[10] += 1
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
== assignments ==
|
||||
fun assignments() : Unit {
|
||||
var x = 1
|
||||
x = 2
|
||||
x += 2
|
||||
|
||||
x = if (true) 1 else 2
|
||||
|
||||
val y = true && false
|
||||
val z = false && true
|
||||
|
||||
val t = Test();
|
||||
t.x = 1
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
r(1)
|
||||
w(x)
|
||||
r(2)
|
||||
w(x)
|
||||
r(x)
|
||||
r(2)
|
||||
r(+=)
|
||||
w(x)
|
||||
r(true)
|
||||
jf(l2)
|
||||
r(1)
|
||||
jmp(l3)
|
||||
l2:
|
||||
r(2)
|
||||
l3:
|
||||
w(x)
|
||||
r(true)
|
||||
jf(l4)
|
||||
r(false)
|
||||
l4:
|
||||
r(true && false)
|
||||
w(y)
|
||||
r(false)
|
||||
jf(l5)
|
||||
r(true)
|
||||
l5:
|
||||
r(false && true)
|
||||
w(z)
|
||||
r(Test)
|
||||
r(Test())
|
||||
w(t)
|
||||
r(1)
|
||||
r(t)
|
||||
r(=)
|
||||
w(t.x)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1,17 +0,0 @@
|
||||
class Test {
|
||||
var x : Int;
|
||||
}
|
||||
|
||||
fun assignments() : Unit {
|
||||
var x = 1
|
||||
x = 2
|
||||
x += 2
|
||||
|
||||
x = if (true) 1 else 2
|
||||
|
||||
val y = true && false
|
||||
val z = false && true
|
||||
|
||||
val t = Test();
|
||||
t.x = 1
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
== anonymous_0 ==
|
||||
{1}
|
||||
---------------------
|
||||
l2:
|
||||
<START>
|
||||
r(1)
|
||||
l3:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== f ==
|
||||
fun f(a : Boolean) : Unit {
|
||||
1
|
||||
a
|
||||
2.lng
|
||||
foo(a, 3)
|
||||
genfun<Any>()
|
||||
flfun {1}
|
||||
3.equals(4)
|
||||
|
||||
3 equals 4
|
||||
|
||||
1 + 2
|
||||
|
||||
a && true
|
||||
a || false
|
||||
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
r(1)
|
||||
r(a)
|
||||
r(2)
|
||||
r(lng)
|
||||
r(2.lng)
|
||||
r(a)
|
||||
r(3)
|
||||
r(foo)
|
||||
r(foo(a, 3))
|
||||
r(genfun)
|
||||
r(genfun<Any>())
|
||||
rf({1})
|
||||
r(flfun)
|
||||
r(flfun {1})
|
||||
r(3)
|
||||
r(4)
|
||||
r(equals)
|
||||
r(equals(4))
|
||||
r(3.equals(4))
|
||||
r(3)
|
||||
r(4)
|
||||
r(equals)
|
||||
r(3 equals 4)
|
||||
r(1)
|
||||
r(2)
|
||||
r(+)
|
||||
r(1 + 2)
|
||||
r(a)
|
||||
jf(l4)
|
||||
r(true)
|
||||
l4:
|
||||
r(a && true)
|
||||
r(a)
|
||||
jt(l5)
|
||||
r(false)
|
||||
l5:
|
||||
r(a || false)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
l2:
|
||||
<START>
|
||||
r(1)
|
||||
l3:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== foo ==
|
||||
fun foo(a : Boolean, b : Int) : Unit {}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
read (Unit)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== genfun ==
|
||||
fun genfun<T>() : Unit {}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
read (Unit)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== flfun ==
|
||||
fun flfun(f : fun () : Any) : Unit {}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
read (Unit)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1,23 +0,0 @@
|
||||
fun f(a : Boolean) : Unit {
|
||||
1
|
||||
a
|
||||
2.lng
|
||||
foo(a, 3)
|
||||
genfun<Any>()
|
||||
flfun {1}
|
||||
3.equals(4)
|
||||
|
||||
3 equals 4
|
||||
|
||||
1 + 2
|
||||
|
||||
a && true
|
||||
a || false
|
||||
|
||||
}
|
||||
|
||||
fun foo(a : Boolean, b : Int) : Unit {}
|
||||
|
||||
fun genfun<T>() : Unit {}
|
||||
|
||||
fun flfun(f : fun () : Any) : Unit {}
|
||||
@@ -1,11 +0,0 @@
|
||||
== empty ==
|
||||
fun empty() {}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
read (Unit)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1 +0,0 @@
|
||||
fun empty() {}
|
||||
@@ -1,19 +0,0 @@
|
||||
== fail ==
|
||||
fun fail() : Nothing {
|
||||
throw java.lang.RuntimeException()
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
r(java)
|
||||
r(lang)
|
||||
r(java.lang)
|
||||
r(RuntimeException)
|
||||
r(RuntimeException())
|
||||
r(java.lang.RuntimeException())
|
||||
jmp(error)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1,3 +0,0 @@
|
||||
fun fail() : Nothing {
|
||||
throw java.lang.RuntimeException()
|
||||
}
|
||||
@@ -1,508 +0,0 @@
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
jmp?(l2)
|
||||
r(1)
|
||||
l2:
|
||||
r(2)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
jmp?(l2)
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l3)
|
||||
r(2)
|
||||
ret l1
|
||||
jmp(l4)
|
||||
l3:
|
||||
read (Unit)
|
||||
l2:
|
||||
l4:
|
||||
r(2)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== anonymous_0 ==
|
||||
{ () =>
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l3:
|
||||
<START>
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l5)
|
||||
ret l4
|
||||
jmp(l6)
|
||||
l5:
|
||||
read (Unit)
|
||||
l4:
|
||||
l6:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
@{ () =>
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
jmp?(l2)
|
||||
r(1)
|
||||
rf({ () =>
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
})
|
||||
l2:
|
||||
r(2)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
l3:
|
||||
<START>
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l5)
|
||||
ret l4
|
||||
jmp(l6)
|
||||
l5:
|
||||
read (Unit)
|
||||
l4:
|
||||
l6:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== anonymous_1 ==
|
||||
{ () =>
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l2:
|
||||
<START>
|
||||
jmp?(l4)
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l5)
|
||||
r(2)
|
||||
ret l3
|
||||
jmp(l6)
|
||||
l5:
|
||||
read (Unit)
|
||||
l4:
|
||||
l6:
|
||||
r(2)
|
||||
l3:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
@{ () =>
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
rf({ () =>
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
})
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
l2:
|
||||
<START>
|
||||
jmp?(l4)
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l5)
|
||||
r(2)
|
||||
ret l3
|
||||
jmp(l6)
|
||||
l5:
|
||||
read (Unit)
|
||||
l4:
|
||||
l6:
|
||||
r(2)
|
||||
l3:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
@ while(true) {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
l2:
|
||||
l5:
|
||||
r(true)
|
||||
jf(l3)
|
||||
l4:
|
||||
jmp?(l6)
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l7)
|
||||
r(2)
|
||||
jmp(l3)
|
||||
jmp(l8)
|
||||
l7:
|
||||
read (Unit)
|
||||
l6:
|
||||
l8:
|
||||
r(2)
|
||||
jmp(l2)
|
||||
l3:
|
||||
read (Unit)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
@ while(true) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
}
|
||||
5
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
jmp?(l2)
|
||||
l3:
|
||||
l6:
|
||||
r(true)
|
||||
jf(l4)
|
||||
l5:
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l7)
|
||||
jmp(l4)
|
||||
jmp(l8)
|
||||
l7:
|
||||
read (Unit)
|
||||
l8:
|
||||
jmp(l3)
|
||||
l4:
|
||||
read (Unit)
|
||||
r(5)
|
||||
l2:
|
||||
r(2)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
@ while(true) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
jmp?(l2)
|
||||
l3:
|
||||
l6:
|
||||
r(true)
|
||||
jf(l4)
|
||||
l5:
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l7)
|
||||
jmp(l4)
|
||||
jmp(l8)
|
||||
l7:
|
||||
read (Unit)
|
||||
l8:
|
||||
jmp(l3)
|
||||
l4:
|
||||
read (Unit)
|
||||
l2:
|
||||
r(2)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3(a : Int) {
|
||||
@ for (i in 1..a) {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
r(1)
|
||||
r(a)
|
||||
r(..)
|
||||
r(1..a)
|
||||
l3:
|
||||
jmp?(l2)
|
||||
l4:
|
||||
l5:
|
||||
jmp?(l6)
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l7)
|
||||
r(2)
|
||||
jmp(l4)
|
||||
jmp(l8)
|
||||
l7:
|
||||
read (Unit)
|
||||
l6:
|
||||
l8:
|
||||
r(2)
|
||||
jmp?(l4)
|
||||
l2:
|
||||
read (Unit)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3(a : Int) {
|
||||
try {
|
||||
@ for (i in 1..a) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
}
|
||||
5
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
jmp?(l2)
|
||||
r(1)
|
||||
r(a)
|
||||
r(..)
|
||||
r(1..a)
|
||||
l4:
|
||||
jmp?(l3)
|
||||
l5:
|
||||
l6:
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l7)
|
||||
jmp(l5)
|
||||
jmp(l8)
|
||||
l7:
|
||||
read (Unit)
|
||||
l8:
|
||||
jmp?(l5)
|
||||
l3:
|
||||
read (Unit)
|
||||
r(5)
|
||||
l2:
|
||||
r(2)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3(a : Int) {
|
||||
try {
|
||||
@ for (i in 1..a) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
jmp?(l2)
|
||||
r(1)
|
||||
r(a)
|
||||
r(..)
|
||||
r(1..a)
|
||||
l4:
|
||||
jmp?(l3)
|
||||
l5:
|
||||
l6:
|
||||
r(1)
|
||||
r(2)
|
||||
r(3)
|
||||
r(>)
|
||||
r(2 > 3)
|
||||
jf(l7)
|
||||
jmp(l5)
|
||||
jmp(l8)
|
||||
l7:
|
||||
read (Unit)
|
||||
l8:
|
||||
jmp?(l5)
|
||||
l3:
|
||||
read (Unit)
|
||||
l2:
|
||||
r(2)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== tf ==
|
||||
fun tf() {
|
||||
try {
|
||||
return 1
|
||||
}
|
||||
finally {
|
||||
return 2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
jmp?(l2)
|
||||
r(1)
|
||||
r(2)
|
||||
ret(*) l1
|
||||
ret(*) l1
|
||||
l2:
|
||||
r(2)
|
||||
ret(*) l1
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1,133 +0,0 @@
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
@{ () =>
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
@{ () =>
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
@ while(true) {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
try {
|
||||
@ while(true) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
}
|
||||
5
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
try {
|
||||
@ while(true) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3(a : Int) {
|
||||
@ for (i in 1..a) {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun t3(a : Int) {
|
||||
try {
|
||||
@ for (i in 1..a) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
}
|
||||
5
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3(a : Int) {
|
||||
try {
|
||||
@ for (i in 1..a) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun tf() {
|
||||
try {
|
||||
return 1
|
||||
}
|
||||
finally {
|
||||
return 2
|
||||
}
|
||||
}
|
||||
@@ -1,72 +0,0 @@
|
||||
== lazyBooleans ==
|
||||
fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
|
||||
if (a) {
|
||||
1
|
||||
}
|
||||
else {
|
||||
2
|
||||
}
|
||||
3
|
||||
if (a && b) 5 else 6
|
||||
7
|
||||
if (a || b) 8 else 9
|
||||
10
|
||||
if (a) 11
|
||||
12
|
||||
if (a) else 13
|
||||
14
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
r(a)
|
||||
jf(l2)
|
||||
r(1)
|
||||
jmp(l3)
|
||||
l2:
|
||||
r(2)
|
||||
l3:
|
||||
r(3)
|
||||
r(a)
|
||||
jf(l4)
|
||||
r(b)
|
||||
l4:
|
||||
jf(l5)
|
||||
r(5)
|
||||
jmp(l6)
|
||||
l5:
|
||||
r(6)
|
||||
l6:
|
||||
r(7)
|
||||
r(a)
|
||||
jt(l7)
|
||||
r(b)
|
||||
l7:
|
||||
jf(l8)
|
||||
r(8)
|
||||
jmp(l9)
|
||||
l8:
|
||||
r(9)
|
||||
l9:
|
||||
r(10)
|
||||
r(a)
|
||||
jf(l10)
|
||||
r(11)
|
||||
jmp(l11)
|
||||
l10:
|
||||
read (Unit)
|
||||
l11:
|
||||
r(12)
|
||||
r(a)
|
||||
jf(l12)
|
||||
read (Unit)
|
||||
jmp(l13)
|
||||
l12:
|
||||
r(13)
|
||||
l13:
|
||||
r(14)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1,17 +0,0 @@
|
||||
fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
|
||||
if (a) {
|
||||
1
|
||||
}
|
||||
else {
|
||||
2
|
||||
}
|
||||
3
|
||||
if (a && b) 5 else 6
|
||||
7
|
||||
if (a || b) 8 else 9
|
||||
10
|
||||
if (a) 11
|
||||
12
|
||||
if (a) else 13
|
||||
14
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
== main ==
|
||||
fun main() {
|
||||
while(1 > 0) {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
l2:
|
||||
l5:
|
||||
r(1)
|
||||
r(0)
|
||||
r(>)
|
||||
r(1 > 0)
|
||||
jf(l3)
|
||||
l4:
|
||||
r(2)
|
||||
jmp(l2)
|
||||
l3:
|
||||
read (Unit)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
== dowhile ==
|
||||
fun dowhile() {
|
||||
do {return}
|
||||
while(1 > 0)
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
l2:
|
||||
l4:
|
||||
ret l1
|
||||
l5:
|
||||
r(1)
|
||||
r(0)
|
||||
r(>)
|
||||
r(1 > 0)
|
||||
jt(l2)
|
||||
l3:
|
||||
read (Unit)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1,10 +0,0 @@
|
||||
fun main() {
|
||||
while(1 > 0) {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun dowhile() {
|
||||
do {return}
|
||||
while(1 > 0)
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
== blockAndAndMismatch ==
|
||||
fun blockAndAndMismatch() : Boolean {
|
||||
false || (return false)
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
r(false)
|
||||
jt(l2)
|
||||
r(false)
|
||||
ret(*) l1
|
||||
l2:
|
||||
r(false || (return false))
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1,3 +0,0 @@
|
||||
fun blockAndAndMismatch() : Boolean {
|
||||
false || (return false)
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
== short ==
|
||||
fun short() = 1
|
||||
---------------------
|
||||
l0:
|
||||
<START>
|
||||
r(1)
|
||||
l1:
|
||||
<END>
|
||||
error:
|
||||
<ERROR>
|
||||
=====================
|
||||
@@ -1 +0,0 @@
|
||||
fun short() = 1
|
||||
@@ -1,166 +0,0 @@
|
||||
namespace abstract
|
||||
|
||||
class MyClass() {
|
||||
//properties
|
||||
val <error>a</error>: Int
|
||||
val a1: Int = 1
|
||||
<error>abstract</error> val a2: Int
|
||||
<error>abstract</error> val a3: Int = 1
|
||||
|
||||
var <error>b</error>: Int private set
|
||||
var b1: Int = 0; private set
|
||||
<error>abstract</error> var b2: Int private set
|
||||
<error>abstract</error> var b3: Int = 0; private set
|
||||
|
||||
var <error>c</error>: Int set(v: Int) { $c = v }
|
||||
var c1: Int = 0; set(v: Int) { $c1 = v }
|
||||
<error>abstract</error> var c2: Int set(v: Int) { $c2 = v }
|
||||
<error>abstract</error> var c3: Int = 0; set(v: Int) { $c3 = v }
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <error>0</error>; get() = a
|
||||
<error>abstract</error> val e2: Int get() = a
|
||||
<error>abstract</error> val e3: Int = 0; get() = a
|
||||
|
||||
//methods
|
||||
fun <error>f</error>()
|
||||
fun g() {}
|
||||
<error>abstract</error> fun h()
|
||||
<error><error>abstract</error></error> fun j() {}
|
||||
}
|
||||
|
||||
abstract class MyAbstractClass() {
|
||||
//properties
|
||||
val <error>a</error>: Int
|
||||
val a1: Int = 1
|
||||
abstract val a2: Int
|
||||
abstract val a3: Int = <error>1</error>
|
||||
|
||||
var <error>b</error>: Int private set
|
||||
var b1: Int = 0; private set
|
||||
abstract var b2: Int private set
|
||||
abstract var b3: Int = <error>0</error>; private set
|
||||
|
||||
var <error>c</error>: Int set(v: Int) { $c = v }
|
||||
var c1: Int = 0; set(v: Int) { $c1 = v }
|
||||
abstract var c2: Int <error>set(v: Int) { $c2 = v }</error>
|
||||
abstract var c3: Int = <error>0</error>; <error>set(v: Int) { $c3 = v }</error>
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <error>0</error>; get() = a
|
||||
abstract val e2: Int <error>get() = a</error>
|
||||
abstract val e3: Int = <error>0</error>; <error>get() = a</error>
|
||||
|
||||
//methods
|
||||
fun <error>f</error>()
|
||||
fun g() {}
|
||||
abstract fun h()
|
||||
<error>abstract</error> fun j() {}
|
||||
}
|
||||
|
||||
trait MyTrait {
|
||||
//properties
|
||||
val a: Int
|
||||
val a1: Int = <error>1</error>
|
||||
<warning>abstract</warning> val a2: Int
|
||||
<warning>abstract</warning> val a3: Int = <error>1</error>
|
||||
|
||||
var b: Int private set
|
||||
var b1: Int = <error>0</error>; private set
|
||||
<warning>abstract</warning> var b2: Int private set
|
||||
<warning>abstract</warning> var b3: Int = <error>0</error>; private set
|
||||
|
||||
var <error>c</error>: Int set(v: Int) { $c = v }
|
||||
var <error>c1</error>: Int = <error>0</error>; set(v: Int) { $c1 = v }
|
||||
<warning>abstract</warning> var c2: Int <error>set(v: Int) { $c2 = v }</error>
|
||||
<warning>abstract</warning> var c3: Int = <error>0</error>; <error>set(v: Int) { $c3 = v }</error>
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <error>0</error>; get() = a
|
||||
<warning>abstract</warning> val e2: Int <error>get() = a</error>
|
||||
<warning>abstract</warning> val e3: Int = <error>0</error>; <error>get() = a</error>
|
||||
|
||||
//methods
|
||||
fun f()
|
||||
fun g() {}
|
||||
<warning>abstract</warning> fun h()
|
||||
<error>abstract</error> fun j() {}
|
||||
}
|
||||
|
||||
enum class MyEnum() {
|
||||
//properties
|
||||
val <error>a</error>: Int
|
||||
val a1: Int = 1
|
||||
abstract val a2: Int
|
||||
abstract val a3: Int = <error>1</error>
|
||||
|
||||
var <error>b</error>: Int private set
|
||||
var b1: Int = 0; private set
|
||||
abstract var b2: Int private set
|
||||
abstract var b3: Int = <error>0</error>; private set
|
||||
|
||||
var <error>c</error>: Int set(v: Int) { $c = v }
|
||||
var c1: Int = 0; set(v: Int) { $c1 = v }
|
||||
abstract var c2: Int <error>set(v: Int) { $c2 = v }</error>
|
||||
abstract var c3: Int = <error>0</error>; <error>set(v: Int) { $c3 = v }</error>
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <error>0</error>; get() = a
|
||||
abstract val e2: Int <error>get() = a</error>
|
||||
abstract val e3: Int = <error>0</error>; <error>get() = a</error>
|
||||
|
||||
//methods
|
||||
fun <error>f</error>()
|
||||
fun g() {}
|
||||
abstract fun h()
|
||||
<error>abstract</error> fun j() {}
|
||||
}
|
||||
|
||||
abstract enum class MyAbstractEnum() {}
|
||||
|
||||
namespace MyNamespace {
|
||||
//properties
|
||||
val <error>a</error>: Int
|
||||
val a1: Int = 1
|
||||
<error>abstract</error> val a2: Int
|
||||
<error>abstract</error> val a3: Int = 1
|
||||
|
||||
var <error>b</error>: Int private set
|
||||
var b1: Int = 0; private set
|
||||
<error>abstract</error> var b2: Int private set
|
||||
<error>abstract</error> var b3: Int = 0; private set
|
||||
|
||||
var <error>c</error>: Int set(v: Int) { $c = v }
|
||||
var c1: Int = 0; set(v: Int) { $c1 = v }
|
||||
<error>abstract</error> var c2: Int set(v: Int) { $c2 = v }
|
||||
<error>abstract</error> var c3: Int = 0; set(v: Int) { $c3 = v }
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <error>0</error>; get() = a
|
||||
<error>abstract</error> val e2: Int get() = a
|
||||
<error>abstract</error> val e3: Int = 0; get() = a
|
||||
|
||||
//methods
|
||||
fun <error>f</error>()
|
||||
fun g() {}
|
||||
<error>abstract</error> fun h()
|
||||
<error>abstract</error> fun j() {}
|
||||
}
|
||||
|
||||
//creating an instance
|
||||
abstract class B1(
|
||||
val i: Int,
|
||||
val s: String
|
||||
) {
|
||||
}
|
||||
|
||||
class B2() : B1(1, "r") {}
|
||||
|
||||
abstract class B3(i: Int) {
|
||||
this(): this(1)
|
||||
}
|
||||
|
||||
fun foo(a: B3) {
|
||||
val a = <error>B3()</error>
|
||||
val b = <error>B1(2, "s")</error>
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
class NoC {
|
||||
<error>{
|
||||
|
||||
}</error>
|
||||
|
||||
val a : Int get() = 1
|
||||
|
||||
<error>{
|
||||
|
||||
}</error>
|
||||
}
|
||||
|
||||
class WithC() {
|
||||
val x : Int
|
||||
{
|
||||
$x = 1
|
||||
<error>$y</error> = 2
|
||||
val b = x
|
||||
|
||||
}
|
||||
|
||||
val a : Int get() = 1
|
||||
|
||||
{
|
||||
val z = <error>b</error>
|
||||
val zz = x
|
||||
val zzz = <error>$a</error>
|
||||
}
|
||||
|
||||
this(a : Int) : this() {
|
||||
val b = x
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
class A() {
|
||||
fun equals(a : Any?) : Boolean = false
|
||||
}
|
||||
|
||||
class B() {
|
||||
fun equals(a : Any?) : Boolean? = false
|
||||
}
|
||||
|
||||
class C() {
|
||||
fun equals(a : Any?) : Int = 0
|
||||
}
|
||||
|
||||
fun f(): Unit {
|
||||
var x: Int? = 1
|
||||
x = 1
|
||||
x <error>+</error> 1
|
||||
x <error>plus</error> 1
|
||||
x <error><</error> 1
|
||||
x <error>+=</error> 1
|
||||
|
||||
x == 1
|
||||
x != 1
|
||||
|
||||
<error>A() == 1</error>
|
||||
B() <error>==</error> 1
|
||||
C() <error>==</error> 1
|
||||
|
||||
<error>x === "1"</error>
|
||||
<error>x !== "1"</error>
|
||||
|
||||
x === 1
|
||||
x !== 1
|
||||
|
||||
x<error>..</error>2
|
||||
<error>x</error> in 1..2
|
||||
|
||||
val y : Boolean? = true
|
||||
false || <error>y</error>
|
||||
<error>y</error> && true
|
||||
<error>y</error> && <error>1</error>
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
namespace boundsWithSubstitutors {
|
||||
open class A<T>
|
||||
class B<X : A<X>>()
|
||||
|
||||
class C : A<C>
|
||||
|
||||
val a = B<C>()
|
||||
val a1 = B<<error>Int</error>>()
|
||||
|
||||
class X<A, B : A>()
|
||||
|
||||
val b = X<Any, X<A<C>, C>>
|
||||
val b0 = X<Any, <error>Any?</error>>
|
||||
val b1 = X<Any, X<A<C>, <error>String</error>>>
|
||||
|
||||
}
|
||||
|
||||
open class A {}
|
||||
open class B<T : A>()
|
||||
|
||||
abstract class C<T : B<<error>Int</error>>, X : fun (B<<error>Char</error>>) : (B<<error>Any</error>>, B<A>)>() : B<<error>Any</error>>() { // 2 errors
|
||||
val a = B<<error>Char</error>>() // error
|
||||
|
||||
abstract val x : fun (B<<error>Char</error>>) : B<<error>Any</error>>
|
||||
}
|
||||
|
||||
|
||||
fun test() {
|
||||
foo<<error>Int?</error>>()
|
||||
foo<Int>()
|
||||
bar<Int?>()
|
||||
bar<Int>()
|
||||
bar<<error>Double?</error>>()
|
||||
bar<<error>Double</error>>()
|
||||
1.buzz<<error>Double</error>>()
|
||||
}
|
||||
|
||||
fun foo<T : Any>() {}
|
||||
fun bar<T : Int?>() {}
|
||||
fun <T : <warning>Int</warning>> Int.buzz() : Unit {}
|
||||
@@ -1,28 +0,0 @@
|
||||
class C {
|
||||
|
||||
fun f (a : Boolean, b : Boolean) {
|
||||
@b (while (true)
|
||||
@a {
|
||||
<error>break@f</error>
|
||||
break
|
||||
break@b
|
||||
<error>break@a</error>
|
||||
})
|
||||
|
||||
<error>continue</error>
|
||||
|
||||
@b (while (true)
|
||||
@a {
|
||||
<error>continue@f</error>
|
||||
continue
|
||||
continue@b
|
||||
<error>continue@a</error>
|
||||
})
|
||||
|
||||
<error>break</error>
|
||||
|
||||
<error>continue@f</error>
|
||||
<error>break@f</error>
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,121 +0,0 @@
|
||||
import java.util.*
|
||||
|
||||
namespace html {
|
||||
|
||||
abstract class Factory<T> {
|
||||
abstract fun create() : T
|
||||
}
|
||||
|
||||
abstract class Element
|
||||
|
||||
class TextElement(val text : String) : Element
|
||||
|
||||
abstract class Tag(val name : String) : Element {
|
||||
val children = ArrayList<Element>()
|
||||
val attributes = HashMap<String, String>()
|
||||
|
||||
protected fun initTag<T : Element>(init : fun T.() : Unit) : T
|
||||
where class object T : Factory<T>{
|
||||
val tag = T.create()
|
||||
tag.init()
|
||||
children.add(tag)
|
||||
return tag
|
||||
}
|
||||
}
|
||||
|
||||
abstract class TagWithText(name : String) : Tag(name) {
|
||||
fun String.plus() {
|
||||
children.add(TextElement(this))
|
||||
}
|
||||
}
|
||||
|
||||
class HTML() : TagWithText("html") {
|
||||
class object : Factory<HTML> {
|
||||
override fun create() = HTML()
|
||||
}
|
||||
|
||||
fun head(init : fun Head.() : Unit) = initTag<Head>(init)
|
||||
|
||||
fun body(init : fun Body.() : Unit) = initTag<Body>(init)
|
||||
}
|
||||
|
||||
class Head() : TagWithText("head") {
|
||||
class object : Factory<Head> {
|
||||
override fun create() = Head()
|
||||
}
|
||||
|
||||
fun title(init : fun Title.() : Unit) = initTag<Title>(init)
|
||||
}
|
||||
|
||||
class Title() : TagWithText("title")
|
||||
|
||||
abstract class BodyTag(name : String) : TagWithText(name) {
|
||||
}
|
||||
|
||||
class Body() : BodyTag("body") {
|
||||
class object : Factory<Body> {
|
||||
override fun create() = Body()
|
||||
}
|
||||
|
||||
fun b(init : fun B.() : Unit) = initTag<B>(init)
|
||||
fun p(init : fun P.() : Unit) = initTag<P>(init)
|
||||
fun h1(init : fun H1.() : Unit) = initTag<H1>(init)
|
||||
fun a(href : String, init : fun A.() : Unit) {
|
||||
val a = initTag<A>(init)
|
||||
a.href = href
|
||||
}
|
||||
}
|
||||
|
||||
class B() : BodyTag("b")
|
||||
class P() : BodyTag("p")
|
||||
class H1() : BodyTag("h1")
|
||||
class A() : BodyTag("a") {
|
||||
var href : String
|
||||
get() = attributes["href"]
|
||||
set(value) { attributes["href"] = value }
|
||||
}
|
||||
|
||||
fun Map<String, String>.set(key : String, value : String) = this.put(key, value)
|
||||
|
||||
fun html(init : fun HTML.() : Unit) : HTML {
|
||||
val html = HTML()
|
||||
html.init()
|
||||
return html
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
namespace foo {
|
||||
|
||||
import html.*
|
||||
|
||||
fun result(args : Array<String>) =
|
||||
html {
|
||||
head {
|
||||
title {+"XML encoding with Groovy"}
|
||||
}
|
||||
body {
|
||||
h1 {+"XML encoding with Groovy"}
|
||||
p {+"this format can be used as an alternative markup to XML"}
|
||||
|
||||
// an element with attributes and text content
|
||||
a(href = "http://groovy.codehaus.org") {+"Groovy"}
|
||||
|
||||
// mixed content
|
||||
p {
|
||||
+"This is some"
|
||||
b {+"mixed"}
|
||||
+"text. For more see the"
|
||||
a(href = "http://groovy.codehaus.org") {+"Groovy"}
|
||||
+"project"
|
||||
}
|
||||
p {+"some text"}
|
||||
|
||||
// content generated by
|
||||
p {
|
||||
for (arg in args)
|
||||
+arg
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
fun test() : Unit {
|
||||
var x : Int? = 0
|
||||
var y : Int = 0
|
||||
|
||||
x : Int?
|
||||
y : Int
|
||||
x as Int : Int
|
||||
y <warning>as</warning> Int : Int
|
||||
x <warning>as</warning> Int? : Int?
|
||||
y <warning>as</warning> Int? : Int?
|
||||
x as? Int : Int?
|
||||
y <warning>as?</warning> Int : Int?
|
||||
x <warning>as?</warning> Int? : Int?
|
||||
y <warning>as?</warning> Int? : Int?
|
||||
()
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
namespace Jet86
|
||||
|
||||
class A {
|
||||
class object {
|
||||
val x = 1
|
||||
}
|
||||
<error>class object { // error
|
||||
val x = 1
|
||||
}</error>
|
||||
}
|
||||
|
||||
class B() {
|
||||
val x = 12
|
||||
}
|
||||
|
||||
object b {
|
||||
<error>class object {
|
||||
val x = 1
|
||||
}</error> // error
|
||||
}
|
||||
|
||||
val a = A.x
|
||||
val c = <error>B</error>.x
|
||||
val d = b.<error>x</error>
|
||||
|
||||
val s = <error>System</error> // error
|
||||
fun test() {
|
||||
System.out?.println()
|
||||
java.lang.System.out?.println()
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
fun test() {
|
||||
1 : Byte
|
||||
1 : Int
|
||||
<error>1</error> : Double
|
||||
1 <warning>as</warning> Byte
|
||||
1 <warning>as</warning> Int
|
||||
<error>1</error> <warning>as</warning> Double
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
|
||||
open class NoC
|
||||
class NoC1 : NoC
|
||||
|
||||
class WithC0() : NoC<error>()</error>
|
||||
open class WithC1() : NoC
|
||||
class NoC2 : <error>WithC1</error>
|
||||
class NoC3 : WithC1<error>()</error>
|
||||
class WithC2() : <error>WithC1</error>
|
||||
|
||||
class NoPC {
|
||||
<error>this</error>() {}
|
||||
}
|
||||
|
||||
class WithPC0() {
|
||||
this(a : Int) : this() {}
|
||||
}
|
||||
|
||||
class WithPC1(a : Int) {
|
||||
<error>this</error>() {}
|
||||
|
||||
this(b : Long) : this("") {}
|
||||
|
||||
this(s : String) : this(1) {}
|
||||
|
||||
this(b : Char) : <error>this</error>("", 2) {}
|
||||
|
||||
this(b : Byte) : this(""), <error>this(1)</error> {}
|
||||
}
|
||||
|
||||
|
||||
class Foo() : <error>WithPC0</error>, <error>this</error>() {
|
||||
|
||||
}
|
||||
|
||||
class WithCPI_Dup(x : Int) {
|
||||
var <error>x</error> : Int
|
||||
}
|
||||
|
||||
class WithCPI(x : Int) {
|
||||
val a = 1
|
||||
val b : Int = $a
|
||||
val xy : Int = x
|
||||
}
|
||||
|
||||
class <error>NoCPI</error> {
|
||||
val a = <error>1</error>
|
||||
var ab = <error>1</error>
|
||||
get() = 1
|
||||
set(v) {}
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
trait A {
|
||||
fun foo() {}
|
||||
}
|
||||
trait B : A, <error>E</error> {}
|
||||
trait C : B {}
|
||||
trait D : <error>B</error> {}
|
||||
trait E : <error>F</error> {}
|
||||
trait F : <error>D</error>, C {}
|
||||
trait G : F {}
|
||||
trait H : F {}
|
||||
|
||||
val a : A? = null
|
||||
val b : B? = null
|
||||
val c : C? = null
|
||||
val d : D? = null
|
||||
val e : E? = null
|
||||
val f : F? = null
|
||||
val g : G? = null
|
||||
val h : H? = null
|
||||
|
||||
fun test() {
|
||||
a?.foo()
|
||||
b?.foo()
|
||||
c?.foo()
|
||||
d?.foo()
|
||||
e?.<error>foo</error>()
|
||||
f?.foo()
|
||||
g?.foo()
|
||||
h?.foo()
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
enum class List<out T>(val size : Int) {
|
||||
Nil : List<Nothing>(0) {
|
||||
val a = 1
|
||||
}
|
||||
Cons<out T>(val head : T, val tail : List<T>) : List<T>(tail.size + 1)
|
||||
|
||||
}
|
||||
|
||||
val foo = List.Nil
|
||||
val foo1 = foo.a
|
||||
@@ -1,71 +0,0 @@
|
||||
fun Int?.optint() : Unit {}
|
||||
val Int?.optval : Unit = ()
|
||||
|
||||
fun <T, E> T.foo(x : E, y : A) : T {
|
||||
y.plus(1)
|
||||
y plus 1
|
||||
y + 1.0
|
||||
|
||||
this<warning>?.</warning>minus<T>(this)
|
||||
|
||||
return this
|
||||
}
|
||||
|
||||
class A
|
||||
|
||||
fun A.plus(a : Any) {
|
||||
|
||||
1.foo()
|
||||
true.<error>foo</error>()
|
||||
|
||||
1
|
||||
}
|
||||
|
||||
fun A.plus(a : Int) {
|
||||
1
|
||||
}
|
||||
|
||||
fun <T> T.minus(t : T) : Int = 1
|
||||
|
||||
fun test() {
|
||||
val y = 1.abs
|
||||
}
|
||||
val Int.abs : Int
|
||||
get() = if (this > 0) this else -this;
|
||||
|
||||
val <T> T.<error>foo</error> : T
|
||||
|
||||
fun Int.foo() = this
|
||||
|
||||
namespace null_safety {
|
||||
|
||||
fun parse(cmd: String): Command? { return null }
|
||||
class Command() {
|
||||
// fun equals(other : Any?) : Boolean
|
||||
val foo : Int = 0
|
||||
}
|
||||
|
||||
fun Any.equals(other : Any?) : Boolean = true
|
||||
fun Any?.equals1(other : Any?) : Boolean = true
|
||||
fun Any.equals2(other : Any?) : Boolean = true
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
|
||||
System.out?.print(1)
|
||||
|
||||
val command = parse("")
|
||||
|
||||
command.foo
|
||||
|
||||
command.equals(null)
|
||||
command?.equals(null)
|
||||
command.equals1(null)
|
||||
command<warning>?.</warning>equals1(null)
|
||||
|
||||
val c = Command()
|
||||
c<warning>?.</warning>equals2(null)
|
||||
|
||||
if (command == null) 1
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,81 +0,0 @@
|
||||
import java.util.*;
|
||||
|
||||
class NotRange1() {
|
||||
|
||||
}
|
||||
|
||||
abstract class NotRange2() {
|
||||
abstract fun iterator() : Unit
|
||||
}
|
||||
|
||||
abstract class ImproperIterator1 {
|
||||
abstract fun hasNext() : Boolean
|
||||
}
|
||||
|
||||
abstract class NotRange3() {
|
||||
abstract fun iterator() : ImproperIterator1
|
||||
}
|
||||
|
||||
abstract class ImproperIterator2 {
|
||||
abstract fun next() : Boolean
|
||||
}
|
||||
|
||||
abstract class NotRange4() {
|
||||
abstract fun iterator() : ImproperIterator2
|
||||
}
|
||||
|
||||
abstract class ImproperIterator3 {
|
||||
abstract fun hasNext() : Int
|
||||
abstract fun next() : Int
|
||||
}
|
||||
|
||||
abstract class NotRange5() {
|
||||
abstract fun iterator() : ImproperIterator3
|
||||
}
|
||||
|
||||
abstract class AmbiguousHasNextIterator {
|
||||
abstract fun hasNext() : Boolean
|
||||
val hasNext : Boolean get() = false
|
||||
abstract fun next() : Int
|
||||
}
|
||||
|
||||
abstract class NotRange6() {
|
||||
abstract fun iterator() : AmbiguousHasNextIterator
|
||||
}
|
||||
|
||||
abstract class ImproperIterator4 {
|
||||
val hasNext : Int get() = 1
|
||||
abstract fun next() : Int
|
||||
}
|
||||
|
||||
abstract class NotRange7() {
|
||||
abstract fun iterator() : ImproperIterator3
|
||||
}
|
||||
|
||||
abstract class GoodIterator {
|
||||
abstract fun hasNext() : Boolean
|
||||
abstract fun next() : Int
|
||||
}
|
||||
|
||||
abstract class Range0() {
|
||||
abstract fun iterator() : GoodIterator
|
||||
}
|
||||
|
||||
abstract class Range1() {
|
||||
abstract fun iterator() : Iterator<Int>
|
||||
}
|
||||
|
||||
fun test(notRange1: NotRange1, notRange2: NotRange2, notRange3: NotRange3, notRange4: NotRange4, notRange5: NotRange5, notRange6: NotRange6, notRange7: NotRange7, range0: Range0, range1: Range1) {
|
||||
for (i in <error>notRange1</error>);
|
||||
for (i in <error>notRange2</error>);
|
||||
for (i in <error>notRange3</error>);
|
||||
for (i in <error>notRange4</error>);
|
||||
for (i in <error>notRange5</error>);
|
||||
for (i in <error>notRange6</error>);
|
||||
for (i in <error>notRange7</error>);
|
||||
for (i in range0);
|
||||
for (i in range1);
|
||||
|
||||
for (i in (ArrayList<Int>() : List<Int>));
|
||||
}
|
||||
|
||||
@@ -1,166 +0,0 @@
|
||||
fun none() {}
|
||||
|
||||
fun unitEmptyInfer() {}
|
||||
fun unitEmpty() : Unit {}
|
||||
fun unitEmptyReturn() : Unit {return}
|
||||
fun unitIntReturn() : Unit {return <error>1</error>}
|
||||
fun unitUnitReturn() : Unit {return ()}
|
||||
fun test1() : Any = {<error>return</error>}
|
||||
fun test2() : Any = @a {return@a 1}
|
||||
fun test3() : Any { <error>return</error> }
|
||||
|
||||
fun bbb() {
|
||||
return <error>1</error>
|
||||
}
|
||||
|
||||
fun foo(expr: StringBuilder): Int {
|
||||
val c = 'a'
|
||||
when(c) {
|
||||
0.chr => throw Exception("zero")
|
||||
else => throw Exception("nonzero" + c)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fun unitShort() : Unit = ()
|
||||
fun unitShortConv() : Unit = <error>1</error>
|
||||
fun unitShortNull() : Unit = <error>null</error>
|
||||
|
||||
fun intEmpty() : Int <error>{}</error>
|
||||
fun intShortInfer() = 1
|
||||
fun intShort() : Int = 1
|
||||
//fun intBlockInfer() {1}
|
||||
fun intBlock() : Int {return 1}
|
||||
fun intBlock() : Int {<error>1</error>}
|
||||
|
||||
fun intString(): Int = <error>"s"</error>
|
||||
fun intFunctionLiteral(): Int = <error>{ 10 }</error>
|
||||
|
||||
fun blockReturnUnitMismatch() : Int {<error>return</error>}
|
||||
fun blockReturnValueTypeMismatch() : Int {return <error>3.4</error>}
|
||||
fun blockReturnValueTypeMatch() : Int {return 1}
|
||||
fun blockReturnValueTypeMismatchUnit() : Int {return <error>()</error>}
|
||||
|
||||
fun blockAndAndMismatch() : Int {
|
||||
<error>true && false</error>
|
||||
}
|
||||
fun blockAndAndMismatch() : Int {
|
||||
return <error>true && false</error>
|
||||
}
|
||||
fun blockAndAndMismatch() : Int {
|
||||
<error>(return <error>true</error>) && (return <error>false</error>)</error>
|
||||
}
|
||||
|
||||
fun blockAndAndMismatch() : Int {
|
||||
<error>true || false</error>
|
||||
}
|
||||
fun blockAndAndMismatch() : Int {
|
||||
return <error>true || false</error>
|
||||
}
|
||||
fun blockAndAndMismatch() : Int {
|
||||
<error>(return <error>true</error>) || (return <error>false</error>)</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
return if (1 > 2) <error>1.0</error> else <error>2.0</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
return <error>if (1 > 2) 1</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
return <error>if (1 > 2) else 1</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
if (1 > 2)
|
||||
return <error>1.0</error>
|
||||
else return <error>2.0</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
if (1 > 2)
|
||||
return <error>1.0</error>
|
||||
return <error>2.0</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
if (1 > 2)
|
||||
else return <error>1.0</error>
|
||||
return <error>2.0</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
if (1 > 2)
|
||||
<error>1.0</error>
|
||||
else <error>2.0</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
if (1 > 2)
|
||||
1.0
|
||||
else 2.0
|
||||
return 1
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
<error>if (1 > 2)
|
||||
<error>1.0</error></error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
return <error>if (1 > 2)
|
||||
1</error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
<error>if (1 > 2)
|
||||
else <error>1.0</error></error>
|
||||
}
|
||||
fun blockReturnValueTypeMatch() : Int {
|
||||
if (1 > 2)
|
||||
return 1
|
||||
else return <error>1.0</error>
|
||||
}
|
||||
fun blockNoReturnIfValDeclaration(): Int {
|
||||
<error>val x = 1</error>
|
||||
}
|
||||
fun blockNoReturnIfEmptyIf(): Int {
|
||||
if (1 < 2) <error>{}</error> else <error>{}</error>
|
||||
}
|
||||
fun blockNoReturnIfUnitInOneBranch(): Int {
|
||||
if (1 < 2) {
|
||||
return 1
|
||||
} else {
|
||||
if (3 < 4) <error>{
|
||||
}</error> else {
|
||||
return 2
|
||||
}
|
||||
}
|
||||
}
|
||||
fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <error>{}</error> else <error>{}</error>
|
||||
fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) <error>{}</error> else 2
|
||||
|
||||
val a = <error>return 1</error>
|
||||
|
||||
class A() {
|
||||
this(a : Int) : this() {
|
||||
if (a == 1)
|
||||
return
|
||||
return <error>1</error>
|
||||
}
|
||||
|
||||
}
|
||||
fun illegalConstantBody(): Int = <error>"s"</error>
|
||||
fun illegalConstantBlock(): String {
|
||||
return <error>1</error>
|
||||
}
|
||||
fun illegalIfBody(): Int =
|
||||
if (1 < 2) <error>'a'</error> else { <error>1.0</error> }
|
||||
fun illegalIfBlock(): Boolean {
|
||||
if (1 < 2)
|
||||
return false
|
||||
else { return <error>1</error> }
|
||||
}
|
||||
fun illegalReturnIf(): Char {
|
||||
return if (1 < 2) 'a' else { <error>1</error> }
|
||||
}
|
||||
|
||||
fun returnNothing(): Nothing {
|
||||
throw 1
|
||||
}
|
||||
fun f(): Int {
|
||||
if (1 < 2) { return 1 } else returnNothing()
|
||||
}
|
||||
|
||||
fun f(): Int = if (1 < 2) 1 else returnNothing()
|
||||
@@ -1,42 +0,0 @@
|
||||
trait A<in T> {}
|
||||
trait B<T> : A<Int> {}
|
||||
trait C<T> : <error>B<T>, A<T></error> {}
|
||||
trait C1<T> : B<T>, A<Any> {}
|
||||
trait D : <error>C<Boolean>, B<Double></error>{}
|
||||
|
||||
trait A1<out T> {}
|
||||
trait B1 : A1<Int> {}
|
||||
trait B2 : A1<Any>, B1 {}
|
||||
|
||||
trait BA1<T> {}
|
||||
trait BB1 : BA1<Int> {}
|
||||
trait BB2 : <error>BA1<Any>, BB1</error> {}
|
||||
|
||||
|
||||
namespace x {
|
||||
trait AA1<out T> {}
|
||||
trait AB1 : AA1<Int> {}
|
||||
trait AB3 : AA1<Comparable<Int>> {}
|
||||
trait AB2 : AA1<Number>, AB1, AB3 {}
|
||||
}
|
||||
|
||||
namespace x2 {
|
||||
trait AA1<out T> {}
|
||||
trait AB1 : AA1<Any> {}
|
||||
trait AB3 : AA1<Comparable<Int>> {}
|
||||
trait AB2 : <error>AA1<Number>, AB1, AB3</error> {}
|
||||
}
|
||||
|
||||
namespace x3 {
|
||||
trait AA1<in T> {}
|
||||
trait AB1 : AA1<Any> {}
|
||||
trait AB3 : AA1<Comparable<Int>> {}
|
||||
trait AB2 : AA1<Number>, AB1, AB3 {}
|
||||
}
|
||||
|
||||
namespace sx2 {
|
||||
trait AA1<in T> {}
|
||||
trait AB1 : AA1<Int> {}
|
||||
trait AB3 : AA1<Comparable<Int>> {}
|
||||
trait AB2 : <error>AA1<Number>, AB1, AB3</error> {}
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
class IncDec() {
|
||||
fun inc() : IncDec = this
|
||||
fun dec() : IncDec = this
|
||||
}
|
||||
|
||||
fun testIncDec() {
|
||||
var x = IncDec()
|
||||
x++
|
||||
++x
|
||||
x--
|
||||
--x
|
||||
x = x++
|
||||
x = x--
|
||||
x = ++x
|
||||
x = --x
|
||||
}
|
||||
|
||||
class WrongIncDec() {
|
||||
fun inc() : Int = 1
|
||||
fun dec() : Int = 1
|
||||
}
|
||||
|
||||
fun testWrongIncDec() {
|
||||
var x = WrongIncDec()
|
||||
x<error>++</error>
|
||||
<error>++</error>x
|
||||
x<error>--</error>
|
||||
<error>--</error>x
|
||||
}
|
||||
|
||||
class UnitIncDec() {
|
||||
fun inc() : Unit {}
|
||||
fun dec() : Unit {}
|
||||
}
|
||||
|
||||
fun testUnitIncDec() {
|
||||
var x = UnitIncDec()
|
||||
x++
|
||||
++x
|
||||
x--
|
||||
--x
|
||||
x = <error>x++</error>
|
||||
x = <error>x--</error>
|
||||
x = <error>++x</error>
|
||||
x = <error>--x</error>
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
fun test() {
|
||||
if (1 is Int) {
|
||||
if (1 is <error>Boolean</error>) {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,72 +0,0 @@
|
||||
namespace Jet87
|
||||
|
||||
open class A() {
|
||||
fun foo() : Int = 1
|
||||
}
|
||||
|
||||
trait B {
|
||||
fun bar() : Double = 1.0;
|
||||
}
|
||||
|
||||
class C() : A(), B
|
||||
|
||||
class D() {
|
||||
class object : A(), B {}
|
||||
}
|
||||
|
||||
class Test1<T : A>()
|
||||
where
|
||||
T : B,
|
||||
<error>B</error> : T, // error
|
||||
class object T : A,
|
||||
class object T : B,
|
||||
class object <error>B</error> : T
|
||||
{
|
||||
|
||||
fun test(t : T) {
|
||||
T.foo()
|
||||
T.bar()
|
||||
t.foo()
|
||||
t.bar()
|
||||
}
|
||||
}
|
||||
|
||||
fun test() {
|
||||
Test1<<error>B</error>>()
|
||||
Test1<<error>A</error>>()
|
||||
Test1<C>()
|
||||
}
|
||||
|
||||
class Foo() {}
|
||||
|
||||
class Bar<T : <warning>Foo</warning>>
|
||||
|
||||
class Buzz<T> where T : <warning>Bar<<error>Int</error>></warning>, T : <error>nioho</error>
|
||||
|
||||
class X<T : <warning>Foo</warning>>
|
||||
class Y<<error>T</error> : <warning>Foo</warning>> where T : <warning>Bar<Foo></warning>
|
||||
|
||||
fun <T : A> test2(t : T)
|
||||
where
|
||||
T : B,
|
||||
<error>B</error> : T,
|
||||
class object <error>B</error> : T,
|
||||
class object T : B,
|
||||
class object T : A
|
||||
{
|
||||
T.foo()
|
||||
T.bar()
|
||||
t.foo()
|
||||
t.bar()
|
||||
}
|
||||
|
||||
val t1 = test2<<error>A</error>>(A())
|
||||
val t2 = test2<<error>B</error>>(C())
|
||||
val t3 = test2<C>(C())
|
||||
|
||||
class Test<<error>T</error>>
|
||||
where
|
||||
class object T : <error>Foo</error>,
|
||||
class object T : A {}
|
||||
|
||||
val <T, B : T> x : Int = 0
|
||||
@@ -1,8 +0,0 @@
|
||||
namespace root
|
||||
|
||||
namespace a {
|
||||
|
||||
}
|
||||
|
||||
val x = <error>a</error>
|
||||
val y2 = <error>namespace</error>
|
||||
@@ -1,63 +0,0 @@
|
||||
namespace foobar
|
||||
|
||||
namespace a {
|
||||
import java.*
|
||||
|
||||
val a : util.List<Int>? = null
|
||||
val a1 : <error>List</error><Int>? = null
|
||||
|
||||
}
|
||||
|
||||
abstract class Foo<T>() {
|
||||
abstract val x : T<Int>
|
||||
}
|
||||
|
||||
namespace a {
|
||||
import java.util.*
|
||||
|
||||
val b : List<Int>? = a
|
||||
val b1 : <error>util</error>.List<Int>? = a
|
||||
}
|
||||
|
||||
val x1 = a.a
|
||||
|
||||
val y1 = a.b
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
fun done<O>(result : O) : Iteratee<Any?, O> = StrangeIterateeImpl<Any?, O>(result)
|
||||
|
||||
abstract class Iteratee<in I, out O> {
|
||||
abstract fun process(item : I) : Iteratee<I, O>
|
||||
abstract val isDone : Boolean
|
||||
abstract val result : O
|
||||
abstract fun done() : O
|
||||
}
|
||||
|
||||
class StrangeIterateeImpl<in I, out O>(val obj: O) : Iteratee<I, O> {
|
||||
override fun process(item: I): Iteratee<I, O> = StrangeIterateeImpl<I, O>(obj)
|
||||
override val isDone = true
|
||||
override val result = obj
|
||||
override fun done() = obj
|
||||
}
|
||||
|
||||
abstract class Sum() : Iteratee<Int, Int> {
|
||||
override fun process(item : Int) : Iteratee<Int, Int> {
|
||||
return foobar.done<Int>(item);
|
||||
}
|
||||
abstract override val isDone : Boolean
|
||||
abstract override val result : Int
|
||||
abstract override fun done() : Int
|
||||
}
|
||||
|
||||
abstract class Collection<E> : Iterable<E> {
|
||||
fun iterate<O>(iteratee : Iteratee<E, O>) : O {
|
||||
for (x in this) {
|
||||
val it = iteratee.process(x)
|
||||
if (it.isDone) return it.result
|
||||
iteratee = it
|
||||
}
|
||||
return iteratee.done()
|
||||
}
|
||||
}
|
||||
@@ -1,280 +0,0 @@
|
||||
fun test() {
|
||||
val a : Int? = 0
|
||||
if (a != null) {
|
||||
a.plus(1)
|
||||
}
|
||||
else {
|
||||
a?.plus(1)
|
||||
}
|
||||
|
||||
val out : java.io.PrintStream? = null//= System.out
|
||||
val ins = System.`in`
|
||||
|
||||
out?.println()
|
||||
ins?.read()
|
||||
|
||||
if (ins != null) {
|
||||
ins.read()
|
||||
out?.println()
|
||||
if (out != null) {
|
||||
ins.read();
|
||||
out.println();
|
||||
}
|
||||
}
|
||||
|
||||
if (out != null && ins != null) {
|
||||
ins.read();
|
||||
out.println();
|
||||
}
|
||||
|
||||
if (out == null) {
|
||||
out?.println()
|
||||
} else {
|
||||
out.println()
|
||||
}
|
||||
|
||||
if (out != null && ins != null || out != null) {
|
||||
ins?.read();
|
||||
out.println();
|
||||
}
|
||||
|
||||
if (out == null || out.println(0) == ()) {
|
||||
out?.println(1)
|
||||
}
|
||||
else {
|
||||
out.println(2)
|
||||
}
|
||||
|
||||
if (out != null && out.println() == ()) {
|
||||
out.println();
|
||||
}
|
||||
else {
|
||||
out?.println();
|
||||
}
|
||||
|
||||
if (out == null || out != null && out.println() == ()) {
|
||||
out?.println();
|
||||
}
|
||||
else {
|
||||
out.println();
|
||||
}
|
||||
|
||||
if (1 == 2 || out != null && out.println(1) == ()) {
|
||||
out?.println(2);
|
||||
}
|
||||
else {
|
||||
out?.println(3)
|
||||
}
|
||||
|
||||
out?.println()
|
||||
ins?.read()
|
||||
|
||||
if (ins != null) {
|
||||
ins.read()
|
||||
out?.println()
|
||||
if (out != null) {
|
||||
ins.read();
|
||||
out.println();
|
||||
}
|
||||
}
|
||||
|
||||
if (out != null && ins != null) {
|
||||
ins.read();
|
||||
out.println();
|
||||
}
|
||||
|
||||
if (out == null) {
|
||||
out?.println()
|
||||
} else {
|
||||
out.println()
|
||||
}
|
||||
|
||||
if (out != null && ins != null || out != null) {
|
||||
ins?.read();
|
||||
out.println();
|
||||
}
|
||||
|
||||
if (out == null || out.println(0) == ()) {
|
||||
out?.println(1)
|
||||
}
|
||||
else {
|
||||
out.println(2)
|
||||
}
|
||||
|
||||
if (out != null && out.println() == ()) {
|
||||
out.println();
|
||||
}
|
||||
else {
|
||||
out?.println();
|
||||
}
|
||||
|
||||
if (out == null || out != null && out.println() == ()) {
|
||||
out?.println();
|
||||
}
|
||||
else {
|
||||
out.println();
|
||||
}
|
||||
|
||||
if (1 == 2 || out != null && out.println(1) == ()) {
|
||||
out?.println(2);
|
||||
}
|
||||
else {
|
||||
out?.println(3)
|
||||
}
|
||||
|
||||
if (1 > 2) {
|
||||
if (out == null) return;
|
||||
out.println();
|
||||
}
|
||||
out?.println();
|
||||
|
||||
while (out != null) {
|
||||
out.println();
|
||||
}
|
||||
out?.println();
|
||||
|
||||
while (out == null) {
|
||||
out?.println();
|
||||
}
|
||||
out.println()
|
||||
|
||||
}
|
||||
|
||||
|
||||
fun f(out : String?) {
|
||||
out?.get(0)
|
||||
if (out != null) else return;
|
||||
out.get(0)
|
||||
}
|
||||
|
||||
fun f1(out : String?) {
|
||||
out?.get(0)
|
||||
if (out != null) else {
|
||||
1 + 2
|
||||
return;
|
||||
}
|
||||
out.get(0)
|
||||
}
|
||||
|
||||
fun f2(out : String?) {
|
||||
out?.get(0)
|
||||
if (out == null) {
|
||||
1 + 2
|
||||
return;
|
||||
}
|
||||
out.get(0)
|
||||
}
|
||||
|
||||
fun f3(out : String?) {
|
||||
out?.get(0)
|
||||
if (out == null) {
|
||||
1 + 2
|
||||
return;
|
||||
}
|
||||
else {
|
||||
1 + 2
|
||||
}
|
||||
out.get(0)
|
||||
}
|
||||
|
||||
fun f4(s : String?) {
|
||||
s?.get(0)
|
||||
while (1 < 2 && s != null) {
|
||||
s.get(0)
|
||||
}
|
||||
s?.get(0)
|
||||
while (s == null || 1 < 2) {
|
||||
s?.get(0)
|
||||
}
|
||||
s.get(0)
|
||||
}
|
||||
|
||||
fun f5(s : String?) {
|
||||
s?.get(0)
|
||||
while (1 < 2 && s != null) {
|
||||
s.get(0)
|
||||
}
|
||||
s?.get(0)
|
||||
while (s == null || 1 < 2) {
|
||||
if (1 > 2) break
|
||||
s?.get(0)
|
||||
}
|
||||
s?.get(0);
|
||||
}
|
||||
|
||||
fun f6(s : String?) {
|
||||
s?.get(0)
|
||||
do {
|
||||
s?.get(0)
|
||||
if (1 < 2) break;
|
||||
} while (s == null)
|
||||
s?.get(0)
|
||||
do {
|
||||
s?.get(0)
|
||||
} while (s == null)
|
||||
s.get(0)
|
||||
}
|
||||
|
||||
fun f7(s : String?, t : String?) {
|
||||
s?.get(0)
|
||||
if (!(s == null)) {
|
||||
s.get(0)
|
||||
}
|
||||
s?.get(0)
|
||||
if (!(s != null)) {
|
||||
s?.get(0)
|
||||
}
|
||||
else {
|
||||
s.get(0)
|
||||
}
|
||||
s?.get(0)
|
||||
if (!!(s != null)) {
|
||||
s.get(0)
|
||||
}
|
||||
else {
|
||||
s?.get(0)
|
||||
}
|
||||
s?.get(0)
|
||||
t?.get(0)
|
||||
if (!(s == null || t == null)) {
|
||||
s.get(0)
|
||||
t.get(0)
|
||||
}
|
||||
else {
|
||||
s?.get(0)
|
||||
t?.get(0)
|
||||
}
|
||||
s?.get(0)
|
||||
t?.get(0)
|
||||
if (!(s == null && s == null)) {
|
||||
s.get(0)
|
||||
t?.get(0)
|
||||
}
|
||||
else {
|
||||
s?.get(0)
|
||||
t?.get(0)
|
||||
}
|
||||
}
|
||||
|
||||
fun f8(b : String?, a : String) {
|
||||
b?.get(0)
|
||||
if (b == a) {
|
||||
b.get(0);
|
||||
}
|
||||
b?.get(0)
|
||||
if (a == b) {
|
||||
b.get(0)
|
||||
}
|
||||
if (a != b) {
|
||||
b?.get(0)
|
||||
}
|
||||
else {
|
||||
b.get(0)
|
||||
}
|
||||
}
|
||||
|
||||
fun f9(a : Int?) : Int {
|
||||
if (a != null)
|
||||
return a
|
||||
return 1
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
namespace toplevelObjectDeclarations {
|
||||
open class Foo(y : Int) {
|
||||
open fun foo() : Int = 1
|
||||
}
|
||||
|
||||
class T : <error>Foo</error> {}
|
||||
|
||||
object A : <error>Foo</error> {
|
||||
val x : Int = 2
|
||||
|
||||
fun test() : Int {
|
||||
return x + foo()
|
||||
}
|
||||
}
|
||||
|
||||
object B : <error>A</error> {}
|
||||
|
||||
val x = A.foo()
|
||||
|
||||
val y = object : Foo(x) {
|
||||
{
|
||||
x + 12
|
||||
}
|
||||
|
||||
override fun foo() : Int = 1
|
||||
}
|
||||
|
||||
val z = y.foo()
|
||||
}
|
||||
|
||||
namespace nestedObejcts {
|
||||
object A {
|
||||
val b = B
|
||||
val d = A.B.A
|
||||
|
||||
object B {
|
||||
val a = A
|
||||
val e = B.A
|
||||
|
||||
object A {
|
||||
val a = A
|
||||
val b = B
|
||||
val x = nestedObejcts.A.B.A
|
||||
val y = this<error>@A</error>
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
object B {
|
||||
val b = B
|
||||
val c = A.B
|
||||
}
|
||||
|
||||
val a = A
|
||||
val b = B
|
||||
val c = A.B
|
||||
val d = A.B.A
|
||||
val e = B.<error>A</error>.B
|
||||
}
|
||||
|
||||
namespace localObjects {
|
||||
object A {
|
||||
val x : Int = 0
|
||||
}
|
||||
|
||||
open class Foo {
|
||||
fun foo() : Int = 1
|
||||
}
|
||||
|
||||
fun test() {
|
||||
A.x
|
||||
val b = object : Foo {
|
||||
}
|
||||
b.foo()
|
||||
|
||||
object B {
|
||||
fun foo() {}
|
||||
}
|
||||
B.foo()
|
||||
}
|
||||
|
||||
val bb = <error>B</error>.foo()
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
namespace override
|
||||
|
||||
namespace normal {
|
||||
trait MyTrait {
|
||||
fun foo()
|
||||
}
|
||||
|
||||
abstract class MyAbstractClass {
|
||||
abstract fun bar()
|
||||
}
|
||||
|
||||
open class MyClass : MyTrait, MyAbstractClass {
|
||||
override fun foo() {}
|
||||
override fun bar() {}
|
||||
}
|
||||
|
||||
class MyChildClass : MyClass {}
|
||||
|
||||
class <error>MyIllegalClass</error> : MyTrait, MyAbstractClass {}
|
||||
|
||||
class <error>MyIllegalClass2</error> : MyTrait, MyAbstractClass {
|
||||
override fun foo() {}
|
||||
}
|
||||
|
||||
class <error>MyIllegalClass3</error> : MyTrait, MyAbstractClass {
|
||||
override fun bar() {}
|
||||
}
|
||||
|
||||
class <error>MyIllegalClass4</error> : MyTrait, MyAbstractClass {
|
||||
fun <error>foo</error>() {}
|
||||
<error>override</error> fun other() {}
|
||||
}
|
||||
|
||||
class MyChildClass1 : MyClass {
|
||||
fun <error>foo</error>() {}
|
||||
override fun bar() {}
|
||||
}
|
||||
}
|
||||
|
||||
namespace generics {
|
||||
trait MyTrait<T> {
|
||||
fun foo(t: T) : T
|
||||
}
|
||||
|
||||
abstract class MyAbstractClass<T> {
|
||||
abstract fun bar(t: T) : T
|
||||
}
|
||||
|
||||
open class MyGenericClass<T> : MyTrait<T>, MyAbstractClass<T> {
|
||||
override fun foo(t: T) = t
|
||||
override fun bar(t: T) = t
|
||||
}
|
||||
|
||||
class MyChildClass : MyGenericClass<Int> {}
|
||||
class MyChildClass1<T> : MyGenericClass<T> {}
|
||||
class MyChildClass2<T> : MyGenericClass<T> {
|
||||
fun <error>foo</error>(t: T) = t
|
||||
override fun bar(t: T) = t
|
||||
}
|
||||
|
||||
open class MyClass : MyTrait<Int>, MyAbstractClass<String> {
|
||||
override fun foo(i: Int) = i
|
||||
override fun bar(s: String) = s
|
||||
}
|
||||
|
||||
class <error>MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T> {}
|
||||
class <error>MyIllegalGenericClass2</error><T, R> : MyTrait<T>, MyAbstractClass<R> {
|
||||
<error>override</error> fun foo(r: R) = r
|
||||
}
|
||||
class <error>MyIllegalClass1</error> : MyTrait<Int>, MyAbstractClass<String> {}
|
||||
|
||||
class <error>MyIllegalClass2</error><T> : MyTrait<Int>, MyAbstractClass<Int> {
|
||||
fun foo(t: T) = t
|
||||
fun bar(t: T) = t
|
||||
}
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
class <error>X</error> {
|
||||
val <error>x</error> : Int
|
||||
}
|
||||
|
||||
open class Y() {
|
||||
val x : Int = 2
|
||||
}
|
||||
|
||||
class Y1 {
|
||||
val x : Int get() = 1
|
||||
}
|
||||
|
||||
class Z : Y<error>()</error> {
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
trait A<T> {}
|
||||
trait B<T> {}
|
||||
trait C<T> {}
|
||||
trait D<T> {}
|
||||
|
||||
trait Test : A<<error>in</error> Int>, B<<error>out</error> Int>, C<<error>*</error>><error>?</error><error>?</error><error>?</error>, D<Int> {}
|
||||
@@ -1,28 +0,0 @@
|
||||
var x : Int = 1 + x
|
||||
get() : Int = 1
|
||||
set(<error>ref</error> value : <error>Long</error>) {
|
||||
$x = value.int
|
||||
$x = <error>1.lng</error>
|
||||
}
|
||||
|
||||
val xx : Int = <error>1 + x</error>
|
||||
get() : Int = 1
|
||||
<error>set(value : Long) {}</error>
|
||||
|
||||
val p : Int = <error>1</error>
|
||||
get() = 1
|
||||
|
||||
class Test() {
|
||||
var a : Int = 111
|
||||
var b : Int get() = <error>$a</error>; set(x) {a = x; <error>$a</error> = x}
|
||||
|
||||
this(i : Int) : this() {
|
||||
<error>$b</error> = $a
|
||||
$a = <error>$b</error>
|
||||
a = <error>$b</error>
|
||||
}
|
||||
fun f() {
|
||||
<error>$b</error> = <error>$a</error>
|
||||
a = <error>$b</error>
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
namespace qualified_expressions
|
||||
|
||||
fun test(s: String?) {
|
||||
val a: Int = <error>s?.length</error>
|
||||
val b: Int? = s?.length
|
||||
val c: Int = s?.length ?: -11
|
||||
val d: Int = s?.length ?: <error>"empty"</error>
|
||||
val e: String = <error>s?.length</error> ?: "empty"
|
||||
val f: Int = s?.length ?: b ?: 1
|
||||
val g: Int? = e? startsWith("s")?.length
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
class Dup {
|
||||
fun Dup() : Unit {
|
||||
this<error>@Dup</error>
|
||||
}
|
||||
}
|
||||
|
||||
class A() {
|
||||
fun foo() : Unit {
|
||||
this@A
|
||||
this<error>@a</error>
|
||||
this
|
||||
}
|
||||
|
||||
val x = this@A.foo()
|
||||
val y = this.foo()
|
||||
val z = foo()
|
||||
}
|
||||
|
||||
fun foo1() : Unit {
|
||||
<error>this</error>
|
||||
this<error>@a</error>
|
||||
}
|
||||
|
||||
namespace closures {
|
||||
class A(val a:Int) {
|
||||
|
||||
class B() {
|
||||
val x = this@B : B
|
||||
val y = this@A : A
|
||||
val z = this : B
|
||||
val Int.xx = this : Int
|
||||
fun Char.xx() : Any {
|
||||
this : Char
|
||||
val a = {Double.() => this : Double + this@xx : Char}
|
||||
val b = @a{Double.() => this@a : Double + this@xx : Char}
|
||||
val c = @a{() => <error>this@a</error> + this@xx : Char}
|
||||
return (@a{Double.() => this@a : Double + this@xx : Char})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
namespace a {
|
||||
val foo = <error>bar()</error>
|
||||
|
||||
fun bar() = foo
|
||||
}
|
||||
|
||||
namespace b {
|
||||
fun foo() = <error>bar()</error>
|
||||
|
||||
fun bar() = foo()
|
||||
}
|
||||
|
||||
namespace c {
|
||||
fun bazz() = <error>bar()</error>
|
||||
|
||||
fun foo() = bazz()
|
||||
|
||||
fun bar() = foo()
|
||||
}
|
||||
|
||||
namespace ok {
|
||||
|
||||
namespace a {
|
||||
val foo = bar()
|
||||
|
||||
fun bar() : Int = foo
|
||||
}
|
||||
|
||||
namespace b {
|
||||
fun foo() : Int = bar()
|
||||
|
||||
fun bar() = foo()
|
||||
}
|
||||
|
||||
namespace c {
|
||||
fun bazz() = bar()
|
||||
|
||||
fun foo() : Int = bazz()
|
||||
|
||||
fun bar() = foo()
|
||||
}
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
namespace redeclarations {
|
||||
object <error>A</error> {
|
||||
val x : Int = 0
|
||||
|
||||
val A = 1
|
||||
}
|
||||
|
||||
namespace <error>A</error> {
|
||||
class A {}
|
||||
}
|
||||
|
||||
class <error>A</error> {}
|
||||
|
||||
val <error>A</error> = 1
|
||||
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
import java.*
|
||||
import util.*
|
||||
import <error>utils</error>.*
|
||||
|
||||
import java.io.PrintStream
|
||||
import java.lang.Comparable as Com
|
||||
|
||||
val l : List<in Int> = ArrayList<Int>()
|
||||
|
||||
fun test(l : java.util.List<Int>) {
|
||||
val x : java.<error>List</error>
|
||||
val y : java.util.List<Int>
|
||||
val b : java.lang.Object
|
||||
val a : util.List<Int>
|
||||
val z : java.<error>utils</error>.List<Int>
|
||||
|
||||
val f : java.io.File? = null
|
||||
|
||||
Collections.<error>emptyList</error>
|
||||
Collections.emptyList<Int>
|
||||
Collections.emptyList<Int>()
|
||||
Collections.emptyList()
|
||||
|
||||
Collections.singleton<Int>(1) : Set<Int>?
|
||||
Collections.singleton<Int>(<error>1.0</error>)
|
||||
|
||||
<error>List</error><Int>
|
||||
|
||||
|
||||
val o = "sdf" <warning>as</warning> Object
|
||||
|
||||
try {
|
||||
// ...
|
||||
}
|
||||
catch(e: Exception) {
|
||||
System.out?.println(e.getMessage())
|
||||
}
|
||||
|
||||
PrintStream("sdf")
|
||||
|
||||
val c : Com<Int>? = null
|
||||
|
||||
c : java.lang.Comparable<Int>?
|
||||
|
||||
// Collections.sort<Integer>(ArrayList<Integer>())
|
||||
xxx.<error>Class</error>()
|
||||
}
|
||||
|
||||
|
||||
namespace xxx {
|
||||
import java.lang.Class;
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
fun demo() {
|
||||
val abc = 1
|
||||
val a = ""
|
||||
val asd = 1
|
||||
val bar = 5
|
||||
fun map(f : fun () : Any?) : Int = 1
|
||||
fun buzz(f : fun () : Any?) : Int = 1
|
||||
val sdf = 1
|
||||
val foo = 3;
|
||||
"$abc"
|
||||
"$"
|
||||
"$.$.asdf$\t"
|
||||
"asd\$"
|
||||
"asd$a<error>\x</error>"
|
||||
"asd$a$asd$ $<error>xxx</error>"
|
||||
"fosdfasdo${1 + bar + 100}}sdsdfgdsfsdf"
|
||||
"foo${bar + map {foo}}sdfsdf"
|
||||
"foo${bar + map { "foo" }}sdfsdf"
|
||||
"foo${bar + map {
|
||||
"foo$sdf${ buzz{}}" }}sdfsdf"
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
// KT-286 Check supertype lists
|
||||
|
||||
/*
|
||||
In a supertype list:
|
||||
Same type should not be mentioned twice
|
||||
Same type should not be indirectly mentioned with incoherent type arguments
|
||||
Every trait's required dependencies should be satisfied
|
||||
No final types should appear
|
||||
Only one class is allowed
|
||||
*/
|
||||
|
||||
class C1()
|
||||
|
||||
open class OC1()
|
||||
|
||||
open class C2 {}
|
||||
|
||||
open class C3 {}
|
||||
|
||||
trait T1 {}
|
||||
|
||||
trait T2<T> {}
|
||||
|
||||
trait Test<error>()</error> {
|
||||
<error>this</error>(x : Int) {}
|
||||
}
|
||||
|
||||
trait Test1 : C2<error>()</error> {}
|
||||
|
||||
trait Test2 : C2 {}
|
||||
|
||||
trait Test3 : C2, <error>C3</error> {}
|
||||
|
||||
trait Test4 : T1 {}
|
||||
|
||||
trait Test5 : T1, <error>T1</error> {}
|
||||
|
||||
trait Test6 : <error>C1</error> {}
|
||||
|
||||
class CTest1() : OC1() {}
|
||||
|
||||
class CTest2 : C2 {}
|
||||
|
||||
class CTest3 : C2, <error>C3</error> {}
|
||||
|
||||
class CTest4 : T1 {}
|
||||
|
||||
class CTest5 : T1, <error>T1</error> {}
|
||||
|
||||
class CTest6 : <error>C1</error> {}
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
open class bar()
|
||||
|
||||
trait Foo<error>()</error> : bar<error>()</error>, <error>bar</error>, <error>bar</error> {
|
||||
<error>this</error>(x : Int) {}
|
||||
}
|
||||
|
||||
trait Foo2 : bar, Foo {
|
||||
}
|
||||
|
||||
open class Foo1() : bar(), <error>bar</error>, Foo, <error>Foo</error><error>()</error> {}
|
||||
open class Foo12 : bar<error>()</error>, <error>bar</error> {}
|
||||
@@ -1,161 +0,0 @@
|
||||
fun t1() : Int{
|
||||
return 0
|
||||
<error>1</error>
|
||||
}
|
||||
|
||||
fun t1a() : Int {
|
||||
<error>return</error>
|
||||
<error>return 1</error>
|
||||
<error>1</error>
|
||||
}
|
||||
|
||||
fun t1b() : Int {
|
||||
return 1
|
||||
<error>return 1</error>
|
||||
<error>1</error>
|
||||
}
|
||||
|
||||
fun t1c() : Int {
|
||||
return 1
|
||||
<error>return</error>
|
||||
<error>1</error>
|
||||
}
|
||||
|
||||
fun t2() : Int {
|
||||
if (1 > 2)
|
||||
return 1
|
||||
else return 1
|
||||
<error>1</error>
|
||||
}
|
||||
|
||||
fun t2a() : Int {
|
||||
if (1 > 2) {
|
||||
return 1
|
||||
<error>1</error>
|
||||
} else { return 1
|
||||
<error>2</error>
|
||||
}
|
||||
<error>1</error>
|
||||
}
|
||||
|
||||
fun t3() : Any {
|
||||
if (1 > 2)
|
||||
return 2
|
||||
else return ""
|
||||
<error>1</error>
|
||||
}
|
||||
|
||||
fun t4(a : Boolean) : Int {
|
||||
do {
|
||||
return 1
|
||||
}
|
||||
while (<error>a</error>)
|
||||
<error>1</error>
|
||||
}
|
||||
|
||||
fun t4break(a : Boolean) : Int {
|
||||
do {
|
||||
break
|
||||
}
|
||||
while (<error>a</error>)
|
||||
return 1
|
||||
}
|
||||
|
||||
fun t5() : Int {
|
||||
do {
|
||||
return 1
|
||||
<error>2</error>
|
||||
}
|
||||
while (<error>1 > 2</error>)
|
||||
<error>return 1</error>
|
||||
}
|
||||
|
||||
fun t6() : Int {
|
||||
while (1 > 2) {
|
||||
return 1
|
||||
<error>2</error>
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
fun t6break() : Int {
|
||||
while (1 > 2) {
|
||||
break
|
||||
<error>2</error>
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
fun t7(b : Int) : Int {
|
||||
for (i in 1..b) {
|
||||
return 1
|
||||
<error>2</error>
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
fun t7break(b : Int) : Int {
|
||||
for (i in 1..b) {
|
||||
return 1
|
||||
<error>2</error>
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
fun t7() : Int {
|
||||
try {
|
||||
return 1
|
||||
<error>2</error>
|
||||
}
|
||||
catch (e : Any) {
|
||||
2
|
||||
}
|
||||
return 1 // this is OK, like in Java
|
||||
}
|
||||
|
||||
fun t8() : Int {
|
||||
try {
|
||||
return 1
|
||||
<error>2</error>
|
||||
}
|
||||
catch (e : Any) {
|
||||
return 1
|
||||
<error>2</error>
|
||||
}
|
||||
<error>return 1</error>
|
||||
}
|
||||
|
||||
fun blockAndAndMismatch() : Boolean {
|
||||
<error>(return true) || (return false)</error>
|
||||
<error>return true</error>
|
||||
}
|
||||
|
||||
fun tf() : Int {
|
||||
try {<error>return 1</error>} finally{return 1}
|
||||
<error>return 1</error>
|
||||
}
|
||||
|
||||
fun failtest(a : Int) : Int {
|
||||
if (fail() || <error>true</error>) {
|
||||
|
||||
}
|
||||
<error>return 1</error>
|
||||
}
|
||||
|
||||
fun foo(a : Nothing) : Unit {
|
||||
1
|
||||
a
|
||||
<error>2</error>
|
||||
}
|
||||
|
||||
fun fail() : Nothing {
|
||||
throw java.lang.RuntimeException()
|
||||
}
|
||||
|
||||
fun nullIsNotNothing() : Unit {
|
||||
val x : Int? = 1
|
||||
if (x != null) {
|
||||
return
|
||||
}
|
||||
fail()
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
namespace unresolved
|
||||
|
||||
fun testGenericArgumentsCount() {
|
||||
val p1: Tuple2<error><Int></error> = (2, 2)
|
||||
val p2: <error>Tuple2</error> = (2, 2)
|
||||
}
|
||||
|
||||
fun testUnresolved() {
|
||||
if (<error>a</error> is String) {
|
||||
val s = <error>a</error>
|
||||
}
|
||||
<error>foo</error>(<error>a</error>)
|
||||
val s = "s"
|
||||
<error>foo</error>(s)
|
||||
foo1(<error>i</error>)
|
||||
s.<error>foo</error>()
|
||||
|
||||
when(<error>a</error>) {
|
||||
is Int => <error>a</error>
|
||||
is String => <error>a</error>
|
||||
}
|
||||
|
||||
//TODO
|
||||
for (j in <error>collection</error>) {
|
||||
val i: Int = j
|
||||
j += 1
|
||||
}
|
||||
}
|
||||
|
||||
fun foo1(i: Int) {}
|
||||
@@ -1,40 +0,0 @@
|
||||
namespace variance
|
||||
|
||||
abstract class Consumer<in T> {}
|
||||
|
||||
abstract class Producer<out T> {}
|
||||
|
||||
abstract class Usual<T> {}
|
||||
|
||||
fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
|
||||
val c1: Consumer<Any> = <error>c</error>
|
||||
val c2: Consumer<Int> = c1
|
||||
|
||||
val p1: Producer<Any> = p
|
||||
val p2: Producer<Int> = <error>p1</error>
|
||||
|
||||
val u1: Usual<Any> = <error>u</error>
|
||||
val u2: Usual<Int> = <error>u1</error>
|
||||
}
|
||||
|
||||
//Arrays copy example
|
||||
class Array<T>(val length : Int) {
|
||||
fun get(index : Int) : T { return null }
|
||||
fun set(index : Int, value : T) { /* ... */ }
|
||||
}
|
||||
|
||||
fun copy1(from : Array<Any>, to : Array<Any>) {}
|
||||
|
||||
fun copy2(from : Array<out Any>, to : Array<in Any>) {}
|
||||
|
||||
fun <T> copy3(from : Array<out T>, to : Array<in T>) {}
|
||||
|
||||
fun copy4(from : Array<out Number>, to : Array<in Int>) {}
|
||||
|
||||
fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
|
||||
copy1(<error>ints</error>, any)
|
||||
copy2(ints, any) //ok
|
||||
copy2(ints, <error>numbers</error>)
|
||||
copy3<Int>(ints, numbers)
|
||||
copy4(ints, numbers) //ok
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
fun Int.foo() : Boolean = true
|
||||
|
||||
fun foo() : Int {
|
||||
val s = ""
|
||||
val x = 1
|
||||
when (x) {
|
||||
is * => 1
|
||||
is <error>String</error> => 1
|
||||
!is Int => 1
|
||||
is Any? => 1
|
||||
<error>s</error> => 1
|
||||
1 => 1
|
||||
1 + <error>a</error> => 1
|
||||
in 1..<error>a</error> => 1
|
||||
!in 1..<error>a</error> => 1
|
||||
.<error>a</error> => 1
|
||||
.equals(1).<error>a</error> => 1
|
||||
<warning>?.</warning>equals(1) => 1
|
||||
else => 1
|
||||
}
|
||||
return when (<warning>x</warning>?:null) {
|
||||
<error>.</error>foo() => 1
|
||||
?.equals(1).equals(2) => 1
|
||||
}
|
||||
}
|
||||
|
||||
val _type_test : Int = foo() // this is needed to ensure the inferred return type of foo()
|
||||
|
||||
fun test() {
|
||||
val x = 1;
|
||||
val s = "";
|
||||
|
||||
when (x) {
|
||||
<error>s</error> => 1
|
||||
is <error>""</error> => 1
|
||||
x => 1
|
||||
is 1 => 1
|
||||
is <error>(1, 1)</error> => 1
|
||||
}
|
||||
|
||||
val z = (1, 1)
|
||||
|
||||
when (z) {
|
||||
is (*, *) => 1
|
||||
is (*, 1) => 1
|
||||
is (1, 1) => 1
|
||||
is (1, <error>"1"</error>) => 1
|
||||
is <error>(1, "1", *)</error> => 1
|
||||
is boo @ (1, <error>"a"</error>, *) => 1
|
||||
is boo @ <error>(1, *)</error> => 1
|
||||
}
|
||||
|
||||
when (z) {
|
||||
<error>else => 1</error>
|
||||
(1, 1) => 2
|
||||
}
|
||||
|
||||
when (z) {
|
||||
else => 1
|
||||
}
|
||||
}
|
||||
|
||||
val (Int, Int).boo : (Int, Int, Int) = (1, 1, 1)
|
||||
@@ -1,253 +0,0 @@
|
||||
<info descr="null">open</info> class A() {
|
||||
fun foo() {}
|
||||
}
|
||||
|
||||
class B() : A() {
|
||||
fun bar() {}
|
||||
}
|
||||
|
||||
fun f9() {
|
||||
val a : A?
|
||||
a?.foo()
|
||||
a?.<error descr="Unresolved reference: bar">bar</error>()
|
||||
if (a is B) {
|
||||
<info descr="Automatically cast to B">a</info>.bar()
|
||||
<info descr="Automatically cast to A">a</info>.foo()
|
||||
}
|
||||
a?.foo()
|
||||
a?.<error descr="Unresolved reference: bar">bar</error>()
|
||||
if (!(a is B)) {
|
||||
a?.<error descr="Unresolved reference: bar">bar</error>()
|
||||
a?.foo()
|
||||
}
|
||||
if (!(a is B) || <info descr="Automatically cast to B">a</info>.bar() == ()) {
|
||||
a?.<error descr="Unresolved reference: bar">bar</error>()
|
||||
}
|
||||
if (!(a is B)) {
|
||||
return;
|
||||
}
|
||||
<info descr="Automatically cast to B">a</info>.bar()
|
||||
<info descr="Automatically cast to A">a</info>.foo()
|
||||
}
|
||||
|
||||
fun f10() {
|
||||
val a : A?
|
||||
if (!(a is B)) {
|
||||
return;
|
||||
}
|
||||
if (!(a is B)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
class C() : A() {
|
||||
fun bar() {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
fun f10(a : A?) {
|
||||
if (a is C) {
|
||||
<info descr="Automatically cast to C">a</info>.bar();
|
||||
}
|
||||
}
|
||||
|
||||
fun f11(a : A?) {
|
||||
when (a) {
|
||||
is B => <info descr="Automatically cast to B">a</info>.bar()
|
||||
is A => <info descr="Automatically cast to A">a</info>.foo()
|
||||
is Any => <info descr="Automatically cast to A">a</info>.foo()
|
||||
is Any? => a.<error descr="Unresolved reference: bar">bar</error>()
|
||||
else => a?.foo()
|
||||
}
|
||||
}
|
||||
|
||||
fun f12(a : A?) {
|
||||
when (a) {
|
||||
is B => <info descr="Automatically cast to B">a</info>.bar()
|
||||
is A => <info descr="Automatically cast to A">a</info>.foo()
|
||||
is Any => <info descr="Automatically cast to A">a</info>.foo();
|
||||
is Any? => a.<error descr="Unresolved reference: bar">bar</error>()
|
||||
is val c : <error descr="[TYPE_MISMATCH_IN_BINDING_PATTERN] B must be a supertype of A?. Use is to match against B">B</error> => c.foo()
|
||||
is val c is C => <info descr="Automatically cast to C">c</info>.bar()
|
||||
is val c is C => <info descr="Automatically cast to C">a</info>.bar()
|
||||
else => a?.foo()
|
||||
}
|
||||
|
||||
if (a is val b) {
|
||||
a?.<error descr="Unresolved reference: bar">bar</error>()
|
||||
b?.foo()
|
||||
}
|
||||
if (a is val b is B) {
|
||||
<info descr="Automatically cast to A">b</info>.foo()
|
||||
<info descr="Automatically cast to B">a</info>.bar()
|
||||
<info descr="Automatically cast to B">b</info>.bar()
|
||||
}
|
||||
}
|
||||
|
||||
fun f13(a : A?) {
|
||||
if (a is val c is B) {
|
||||
<info descr="Automatically cast to A">c</info>.foo()
|
||||
<info descr="Automatically cast to B">c</info>.bar()
|
||||
}
|
||||
else {
|
||||
a?.foo()
|
||||
<error descr="Unresolved reference: c">c</error>.bar()
|
||||
}
|
||||
|
||||
a?.foo()
|
||||
if (!(a is val c is B)) {
|
||||
a?.foo()
|
||||
<error descr="Unresolved reference: c">c</error>.bar()
|
||||
}
|
||||
else {
|
||||
<info descr="Automatically cast to A">a</info>.foo()
|
||||
<error descr="Unresolved reference: c">c</error>.bar()
|
||||
}
|
||||
|
||||
a?.foo()
|
||||
if (a is val c is B && <info descr="Automatically cast to A">a</info>.foo() == () && <info descr="Automatically cast to B">c</info>.bar() == ()) {
|
||||
<info descr="Automatically cast to A">c</info>.foo()
|
||||
<info descr="Automatically cast to B">c</info>.bar()
|
||||
}
|
||||
else {
|
||||
a?.foo()
|
||||
<error descr="Unresolved reference: c">c</error>.bar()
|
||||
}
|
||||
|
||||
if (!(a is val c is B) || !(a is val x is C)) {
|
||||
<error descr="Unresolved reference: x">x</error>
|
||||
<error descr="Unresolved reference: c">c</error>
|
||||
}
|
||||
else {
|
||||
<error descr="Unresolved reference: x">x</error>
|
||||
<error descr="Unresolved reference: c">c</error>
|
||||
}
|
||||
|
||||
if (!(a is val c is B) || !(a is val c is C)) {
|
||||
}
|
||||
|
||||
if (!(a is val c is B)) return
|
||||
<info descr="Automatically cast to B">a</info>.bar()
|
||||
<error descr="Unresolved reference: c">c</error>.foo()
|
||||
<error descr="Unresolved reference: c">c</error>.bar()
|
||||
}
|
||||
|
||||
fun f14(a : A?) {
|
||||
while (!(a is val c is B)) {
|
||||
}
|
||||
<info descr="Automatically cast to B">a</info>.bar()
|
||||
<error descr="Unresolved reference: c">c</error>.bar()
|
||||
}
|
||||
fun f15(a : A?) {
|
||||
do {
|
||||
} while (!(a is val c is B))
|
||||
<info descr="Automatically cast to B">a</info>.bar()
|
||||
<error descr="Unresolved reference: c">c</error>.bar()
|
||||
}
|
||||
|
||||
fun getStringLength(obj : Any) : Char? {
|
||||
if (obj !is String)
|
||||
return null
|
||||
return <info descr="Automatically cast to String">obj</info>.get(0) // no cast to String is needed
|
||||
}
|
||||
|
||||
fun toInt(i: Int?): Int = if (i != null) <info descr="Automatically cast to Int">i</info> else 0
|
||||
fun illegalWhenBody(a: Any): Int = when(a) {
|
||||
is Int => <info descr="Automatically cast to Int">a</info>
|
||||
is String => <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any but Int was expected">a</error>
|
||||
}
|
||||
fun illegalWhenBlock(a: Any): Int {
|
||||
when(a) {
|
||||
is Int => return <info descr="Automatically cast to Int">a</info>
|
||||
is String => return <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any but Int was expected">a</error>
|
||||
}
|
||||
}
|
||||
fun declarations(a: Any?) {
|
||||
if (a is String) {
|
||||
val p4: (Int, String) = (2, <info descr="Automatically cast to String">a</info>)
|
||||
}
|
||||
if (a is String?) {
|
||||
if (a != null) {
|
||||
val s: String = <info descr="Automatically cast to String">a</info>
|
||||
}
|
||||
}
|
||||
if (a != null) {
|
||||
if (a is String?) {
|
||||
val s: String = <info descr="Automatically cast to String">a</info>
|
||||
}
|
||||
}
|
||||
}
|
||||
fun vars(a: Any?) {
|
||||
var b: Int = 0
|
||||
if (a is Int) {
|
||||
b = <info descr="Automatically cast to Int">a</info>
|
||||
}
|
||||
}
|
||||
fun tuples(a: Any?) {
|
||||
if (a != null) {
|
||||
val s: (Any, String) = (<info descr="Automatically cast to Any">a</info>, <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but String was expected">a</error>)
|
||||
}
|
||||
if (a is String) {
|
||||
val s: (Any, String) = (<info descr="Automatically cast to Any">a</info>, <info descr="Automatically cast to String">a</info>)
|
||||
}
|
||||
fun illegalTupleReturnType(): (Any, String) = (<error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but Any was expected">a</error>, <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but String was expected">a</error>)
|
||||
if (a is String) {
|
||||
fun legalTupleReturnType(): (Any, String) = (<info descr="Automatically cast to Any">a</info>, <info descr="Automatically cast to String">a</info>)
|
||||
}
|
||||
val illegalFunctionLiteral: Function0<Int> = <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Function0<Any?> but Function0<Int> was expected">{ <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but Int was expected">a</error> }</error>
|
||||
val illegalReturnValueInFunctionLiteral: Function0<Int> = { (): Int => <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any? but Int was expected">a</error> }
|
||||
|
||||
if (a is Int) {
|
||||
val legalFunctionLiteral: Function0<Int> = { <info descr="Automatically cast to Int">a</info> }
|
||||
val alsoLegalFunctionLiteral: Function0<Int> = { (): Int => <info descr="Automatically cast to Int">a</info> }
|
||||
}
|
||||
}
|
||||
fun returnFunctionLiteralBlock(a: Any?): Function0<Int> {
|
||||
if (a is Int) return { <info descr="Automatically cast to Int">a</info> }
|
||||
else return { 1 }
|
||||
}
|
||||
fun returnFunctionLiteral(a: Any?): Function0<Int> =
|
||||
if (a is Int) { (): Int => <info descr="Automatically cast to Int">a</info> }
|
||||
else { () => 1 }
|
||||
|
||||
fun illegalTupleReturnType(a: Any): (Any, String) = (a, <error descr="[TYPE_MISMATCH] Type mismatch: inferred type is Any but String was expected">a</error>)
|
||||
|
||||
fun declarationInsidePattern(x: (Any, Any)): String = when(x) { is (val a is String, *) => <info descr="Automatically cast to String">a</info>; else => "something" }
|
||||
|
||||
fun mergeAutocasts(a: Any?) {
|
||||
if (a is String || a is Int) {
|
||||
a.<error descr="Unresolved reference: compareTo">compareTo</error>("")
|
||||
a.toString()
|
||||
}
|
||||
if (a is Int || a is String) {
|
||||
a.<error descr="Unresolved reference: compareTo">compareTo</error>("")
|
||||
}
|
||||
when (a) {
|
||||
is String, is Any => a.<error descr="Unresolved reference: compareTo">compareTo</error>("")
|
||||
}
|
||||
if (a is String && a is Any) {
|
||||
val i: Int = <info descr="Automatically cast to String">a</info>.compareTo("")
|
||||
}
|
||||
if (a is String && <info descr="Automatically cast to String">a</info>.compareTo("") == 0) {}
|
||||
if (a is String || a.<error descr="Unresolved reference: compareTo">compareTo</error>("") == 0) {}
|
||||
}
|
||||
|
||||
//mutability
|
||||
fun f(): String {
|
||||
var a: Any = 11
|
||||
if (a is String) {
|
||||
val i: String = <error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to String is impossible, because a could have changed since the is-check">a</error>
|
||||
<error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to String is impossible, because a could have changed since the is-check">a</error>.compareTo("f")
|
||||
val f: Function0<String> = { <error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to String is impossible, because a could have changed since the is-check">a</error> }
|
||||
return <error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to String is impossible, because a could have changed since the is-check">a</error>
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
fun foo(var a: Any): Int {
|
||||
if (a is Int) {
|
||||
return <error descr="[AUTOCAST_IMPOSSIBLE] Automatic cast to Int is impossible, because a could have changed since the is-check">a</error>
|
||||
}
|
||||
return 1
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
<info>abstract</info> class Test() {
|
||||
<info>abstract</info> val x : Int
|
||||
<info>abstract</info> val x1 : Int <info>get</info>
|
||||
<info>abstract</info> val x2 : Int <error><info>get</info>() = 1</error>
|
||||
|
||||
val <error>a</error> : Int
|
||||
val <error>b</error> : Int <info>get</info>
|
||||
val <info>c</info> = 1
|
||||
|
||||
val <info>c1</info> = 1
|
||||
<info>get</info>
|
||||
val c2 : Int
|
||||
<info>get</info>() = 1
|
||||
val c3 : Int
|
||||
<info>get</info>() { return 1 }
|
||||
val c4 : Int
|
||||
<info>get</info>() = 1
|
||||
val <error>c5</error> : Int
|
||||
<info>get</info>() = $c5 + 1
|
||||
|
||||
<info>abstract</info> var y : Int
|
||||
<info>abstract</info> var y1 : Int <info>get</info>
|
||||
<info>abstract</info> var y2 : Int <info>set</info>
|
||||
<info>abstract</info> var y3 : Int <info>set</info> <info>get</info>
|
||||
<info>abstract</info> var y4 : Int <info>set</info> <error><info>get</info>() = 1</error>
|
||||
<info>abstract</info> var y5 : Int <error><info>set</info>(x) {}</error> <error><info>get</info>() = 1</error>
|
||||
<info>abstract</info> var y6 : Int <error><info>set</info>(x) {}</error>
|
||||
|
||||
var <error>v</error> : Int
|
||||
var <error>v1</error> : Int <info>get</info>
|
||||
var <error>v2</error> : Int <info>get</info> <info>set</info>
|
||||
var <error>v3</error> : Int <info>get</info>() = 1; <info>set</info>
|
||||
var v4 : Int <info>get</info>() = 1; <info>set</info>(x){}
|
||||
|
||||
var <error>v5</error> : Int <info>get</info>() = 1; <info>set</info>(x){$v5 = x}
|
||||
var <error>v6</error> : Int <info>get</info>() = $v6 + 1; <info>set</info>(x){}
|
||||
|
||||
var <error>v9</error> : Int <info>set</info>
|
||||
var <error>v10</error> : Int <info>get</info>
|
||||
|
||||
}
|
||||
|
||||
<info>open</info> class Super(i : Int)
|
||||
|
||||
class TestPCParameters(w : Int, x : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(w) {
|
||||
|
||||
val <info>xx</info> = w
|
||||
|
||||
{
|
||||
w + 1
|
||||
}
|
||||
|
||||
fun foo() = <error>x</error>
|
||||
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
fun refs() {
|
||||
var <info>a</info> = 1
|
||||
val v = {
|
||||
<info>a</info> = 2
|
||||
}
|
||||
|
||||
var <info>x</info> = 1
|
||||
val b = object {
|
||||
fun foo() {
|
||||
<info>x</info> = 2
|
||||
}
|
||||
}
|
||||
|
||||
var <info>y</info> = 1
|
||||
fun foo() {
|
||||
<info>y</info> = 1
|
||||
}
|
||||
}
|
||||
|
||||
fun refsPlusAssign() {
|
||||
var <info>a</info> = 1
|
||||
val v = {
|
||||
<info>a</info> += 2
|
||||
}
|
||||
|
||||
var <info>x</info> = 1
|
||||
val b = object {
|
||||
fun foo() {
|
||||
<info>x</info> += 2
|
||||
}
|
||||
}
|
||||
|
||||
var <info>y</info> = 1
|
||||
fun foo() {
|
||||
<info>y</info> += 1
|
||||
}
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
// One of the two passes is making a scope and turning vals into functions
|
||||
// See KT-76
|
||||
|
||||
namespace x
|
||||
|
||||
val b : Foo = Foo()
|
||||
val a1 = b.compareTo(2)
|
||||
|
||||
class Foo() {
|
||||
fun compareTo(other : Byte) : Int = 0
|
||||
fun compareTo(other : Char) : Int = 0
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
fun test() {
|
||||
val a : Any? = null
|
||||
if (a is Any) else a = null;
|
||||
while (a is Any) a = null
|
||||
while (true) a = null
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
fun foo(u : Unit) : Int = 1
|
||||
|
||||
fun test() : Int {
|
||||
foo(<error>1</error>)
|
||||
val a : fun() : Unit = {
|
||||
foo(<error>1</error>)
|
||||
}
|
||||
return 1
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
import java.*
|
||||
import util.*
|
||||
|
||||
import java.io.*
|
||||
|
||||
fun takeFirst(expr: StringBuilder): Char {
|
||||
val c = expr.charAt(0)
|
||||
expr.deleteCharAt(0)
|
||||
return c
|
||||
}
|
||||
|
||||
fun evaluateArg(expr: AbstractStringBuilder, numbers: ArrayList<Int>): Int {
|
||||
if (expr.length() == 0) throw Exception("Syntax error: Character expected");
|
||||
val c = takeFirst(<error>expr</error>)
|
||||
if (c >= '0' && c <= '9') {
|
||||
val n = c - '0'
|
||||
if (!numbers.contains(n)) throw Exception("You used incorrect number: " + n)
|
||||
numbers.remove(n)
|
||||
return n
|
||||
}
|
||||
throw Exception("Syntax error: Unrecognized character " + c)
|
||||
}
|
||||
|
||||
fun evaluateAdd(expr: StringBuilder, numbers: ArrayList<Int>): Int {
|
||||
val lhs = evaluateArg(expr, numbers)
|
||||
if (expr.length() > 0) {
|
||||
|
||||
}
|
||||
return lhs
|
||||
}
|
||||
|
||||
fun evaluate(expr: StringBuilder, numbers: ArrayList<Int>): Int {
|
||||
val lhs = evaluateAdd(expr, numbers)
|
||||
if (expr.length() > 0) {
|
||||
val c = expr.charAt(0)
|
||||
expr.deleteCharAt(0)
|
||||
}
|
||||
return lhs
|
||||
}
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
System.out?.println("24 game")
|
||||
val numbers = ArrayList<Int>(4)
|
||||
val rnd = Random();
|
||||
val prompt = StringBuilder()
|
||||
for(val i in 0..3) {
|
||||
val n = rnd.nextInt(9) + 1
|
||||
numbers.add(n)
|
||||
if (i > 0) prompt.append(" ");
|
||||
prompt.append(n)
|
||||
}
|
||||
System.out?.println("Your numbers: " + prompt)
|
||||
System.out?.println("Enter your expression:")
|
||||
val reader = BufferedReader(InputStreamReader(System.`in`))
|
||||
val expr = StringBuilder(reader.readLine())
|
||||
try {
|
||||
val result = evaluate(expr, numbers)
|
||||
if (result != 24)
|
||||
System.out?.println("Sorry, that's " + result)
|
||||
else
|
||||
System.out?.println("You won!");
|
||||
}
|
||||
catch(e: Throwable) {
|
||||
System.out?.println(e.getMessage())
|
||||
}
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
// JET-11 Redeclaration & Forward reference for classes cause an exception
|
||||
open class <error>NoC</error>
|
||||
class NoC1 : NoC
|
||||
open class <error>NoC</error>
|
||||
@@ -1,14 +0,0 @@
|
||||
namespace jet121 {
|
||||
fun box() : String {
|
||||
val answer = apply("OK") { String.() : Int =>
|
||||
get(0)
|
||||
length
|
||||
}
|
||||
|
||||
return if (answer == 2) "OK" else "FAIL"
|
||||
}
|
||||
|
||||
fun apply(arg:String, f : fun String.() : Int) : Int {
|
||||
return arg.f()
|
||||
}
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
fun foo1() : fun (Int) : Int = { (x: Int) => x }
|
||||
|
||||
fun foo() {
|
||||
val h : fun (Int) : Int = foo1();
|
||||
h(1)
|
||||
val m : fun (Int) : Int = {(a : Int) => 1}//foo1()
|
||||
m(1)
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
fun set(key : String, value : String) {
|
||||
val a : String? = ""
|
||||
when (a) {
|
||||
"" => a<error>.</error>get(0)
|
||||
is String, is Any => a.compareTo("")
|
||||
else => a.toString()
|
||||
}
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
// JET-17 Do not infer property types by the initializer before the containing scope is ready
|
||||
|
||||
class WithC() {
|
||||
val a = 1
|
||||
val b = $a // error here, but must not be
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
abstract enum class ProtocolState {
|
||||
WAITING {
|
||||
override fun signal() = ProtocolState.TALKING
|
||||
}
|
||||
|
||||
TALKING {
|
||||
override fun signal() = ProtocolState.WAITING
|
||||
}
|
||||
|
||||
abstract fun signal() : ProtocolState
|
||||
}
|
||||
|
||||
|
||||
fun box(): String {
|
||||
val x: ProtocolState = ProtocolState.WAITING
|
||||
x = x.signal()
|
||||
if (x != ProtocolState.TALKING) return "fail 1"
|
||||
x = x.signal()
|
||||
if (x != ProtocolState.WAITING) return "fail 2"
|
||||
return "OK"
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
abstract enum class ProtocolState {
|
||||
WAITING {
|
||||
override fun signal() = ProtocolState.TALKING
|
||||
}
|
||||
|
||||
TALKING {
|
||||
override fun signal() = ProtocolState.WAITING
|
||||
}
|
||||
|
||||
abstract fun signal() : ProtocolState
|
||||
}
|
||||
|
||||
enum class Foo<T> {
|
||||
<error>X</error>
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
fun box() {
|
||||
val x: ProtocolState = ProtocolState.WAITING
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
import java.util.Collections
|
||||
import java.util.List
|
||||
|
||||
val ab = Collections.emptyList<Int>() : List<Int>?
|
||||
@@ -1,4 +0,0 @@
|
||||
abstract class XXX {
|
||||
abstract val a : Int get
|
||||
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
class Foo()
|
||||
|
||||
fun test() {
|
||||
val f : Foo? = null
|
||||
if (f == null) {
|
||||
|
||||
}
|
||||
if (f != null) {
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
class Command() {}
|
||||
|
||||
fun parse(cmd: String): Command? { return null }
|
||||
|
||||
fun Any.equals(other : Any?) : Boolean = this === other
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
val command = parse("")
|
||||
if (command == null) 1 // error on this line, but must be OK
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
// JET-72 Type inference doesn't work when iterating over ArrayList
|
||||
|
||||
import java.util.ArrayList
|
||||
|
||||
abstract class Item(val room: Object) {
|
||||
abstract val name : String
|
||||
}
|
||||
|
||||
val items: ArrayList<Item> = ArrayList<Item>
|
||||
|
||||
fun test(room : Object) {
|
||||
for(val item: Item in items) {
|
||||
if (item.room === room) {
|
||||
System.out?.println("You see " + item.name)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
// JET-81 Assertion fails when processing self-referring anonymous objects
|
||||
|
||||
val y = object {
|
||||
val a = y;
|
||||
}
|
||||
|
||||
val z = y.a;
|
||||
|
||||
object A {
|
||||
val x = A
|
||||
}
|
||||
|
||||
val a = object {
|
||||
{
|
||||
b + 1
|
||||
}
|
||||
val x = b
|
||||
val y = 1
|
||||
}
|
||||
|
||||
val b = <error>a</error>.x
|
||||
val c = a.y
|
||||
@@ -1,16 +0,0 @@
|
||||
fun box() {
|
||||
val a : C
|
||||
a.foo()
|
||||
}
|
||||
|
||||
open class A {
|
||||
open fun foo() {}
|
||||
}
|
||||
|
||||
open class B : A {
|
||||
override fun foo() {}
|
||||
}
|
||||
|
||||
open class C : B {
|
||||
override fun foo() {}
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
class Foo(var bar : Int, barr : Int, val barrr : Int) {
|
||||
{
|
||||
bar = 1
|
||||
barr = 1
|
||||
barrr = 1
|
||||
1 : Int
|
||||
this : Foo
|
||||
}
|
||||
|
||||
this(val bar : Int) : this(1, 1, 1) {
|
||||
bar = 1
|
||||
this.bar
|
||||
1 : Int
|
||||
val a : Int =1
|
||||
this : Foo
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
fun Any.equals(other : Any?) : Boolean = true
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
|
||||
val command : Any = 1
|
||||
|
||||
command<warning>?.</warning>equals(null)
|
||||
command.equals(null)
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
class Z() {
|
||||
this(x : Int) : this() {}
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
open class Foo {}
|
||||
open class Bar {}
|
||||
|
||||
fun <T : Bar, T1> foo(x : Int) {}
|
||||
fun <T1, T : Foo> foo(x : Long) {}
|
||||
|
||||
fun f(): Unit {
|
||||
foo<<error>Int</error>, Int>(1)
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
class A() {
|
||||
var x: Int = 0
|
||||
get() = <error>"s"</error>
|
||||
set(value: <error>String</error>) {
|
||||
$x = <error>value</error>
|
||||
}
|
||||
val y: Int
|
||||
get(): <error>String</error> = "s"
|
||||
val z: Int
|
||||
get() {
|
||||
return <error>"s"</error>
|
||||
}
|
||||
|
||||
var a: Any = 1
|
||||
set(v: <error>String</error>) {
|
||||
$a = v
|
||||
}
|
||||
val b: Int
|
||||
get(): <error>Any</error> = "s"
|
||||
val c: Int
|
||||
get() {
|
||||
return 1
|
||||
}
|
||||
val d = 1
|
||||
get() {
|
||||
return $d
|
||||
}
|
||||
val e = 1
|
||||
get(): <error>String</error> {
|
||||
return <error>$e</error>
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
// KT-303 Stack overflow on a cyclic class hierarchy
|
||||
|
||||
open class Foo() : <error>Bar</error>() {
|
||||
val a : Int = 1
|
||||
}
|
||||
|
||||
open class Bar() : <error>Foo</error>() {
|
||||
|
||||
}
|
||||
|
||||
val x : Int = <error>Foo()</error>
|
||||
@@ -1,15 +0,0 @@
|
||||
fun foo(u : Unit) : Int = 1
|
||||
|
||||
fun test() : Int {
|
||||
foo(1)
|
||||
val a : fun() : Unit = {
|
||||
foo(1)
|
||||
}
|
||||
return 1 - "1"
|
||||
}
|
||||
|
||||
class A() {
|
||||
val x : Int = foo1(xx)
|
||||
}
|
||||
|
||||
fun foo1() {}
|
||||
@@ -1,241 +0,0 @@
|
||||
namespace abstract
|
||||
|
||||
class MyClass() {
|
||||
//properties
|
||||
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
|
||||
val a1: Int = 1
|
||||
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a2: Int
|
||||
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a3: Int = 1
|
||||
|
||||
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int private set
|
||||
var b1: Int = 0; private set
|
||||
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b2: Int private set
|
||||
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b3: Int = 0; private set
|
||||
|
||||
var <!MUST_BE_INITIALIZED!>c<!>: Int set(v: Int) { $c = v }
|
||||
var c1: Int = 0; set(v: Int) { $c1 = v }
|
||||
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c2: Int set(v: Int) { $c2 = v }
|
||||
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
|
||||
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e2: Int get() = a
|
||||
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e3: Int = 0; get() = a
|
||||
|
||||
//methods
|
||||
fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
|
||||
fun g() {}
|
||||
<!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> fun h()
|
||||
<!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
|
||||
|
||||
//property accessors
|
||||
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
|
||||
}
|
||||
|
||||
abstract class MyAbstractClass() {
|
||||
//properties
|
||||
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
|
||||
val a1: Int = 1
|
||||
abstract val a2: Int
|
||||
abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
|
||||
|
||||
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int private set
|
||||
var b1: Int = 0; private set
|
||||
abstract var b2: Int private set
|
||||
abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
|
||||
|
||||
var <!MUST_BE_INITIALIZED!>c<!>: Int set(v: Int) { $c = v }
|
||||
var c1: Int = 0; set(v: Int) { $c1 = v }
|
||||
abstract var c2: Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
|
||||
abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
|
||||
abstract val e2: Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
|
||||
abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
|
||||
|
||||
//methods
|
||||
fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
|
||||
fun g() {}
|
||||
abstract fun h()
|
||||
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
|
||||
|
||||
//property accessors
|
||||
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var j1: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
|
||||
}
|
||||
|
||||
trait MyTrait {
|
||||
//properties
|
||||
val a: Int
|
||||
val a1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>1<!>
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val a2: Int
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
|
||||
|
||||
var b: Int private set
|
||||
var b1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; private set
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var b2: Int private set
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
|
||||
|
||||
var <!BACKING_FIELD_IN_TRAIT!>c<!>: Int set(v: Int) { $c = v }
|
||||
var <!BACKING_FIELD_IN_TRAIT!>c1<!>: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; set(v: Int) { $c1 = v }
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var c2: Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; get() = a
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val e2: Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
|
||||
|
||||
//methods
|
||||
fun f()
|
||||
fun g() {}
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT!>abstract<!> fun h()
|
||||
<!REDUNDANT_MODIFIER_IN_TRAIT, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
|
||||
|
||||
//property accessors
|
||||
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var i1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var j1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var k: Int <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var k1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var l1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
|
||||
}
|
||||
|
||||
enum class MyEnum() {
|
||||
//properties
|
||||
val <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>a<!>: Int
|
||||
val a1: Int = 1
|
||||
abstract val a2: Int
|
||||
abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
|
||||
|
||||
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>b<!>: Int private set
|
||||
var b1: Int = 0; private set
|
||||
abstract var b2: Int private set
|
||||
abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; private set
|
||||
|
||||
var <!MUST_BE_INITIALIZED!>c<!>: Int set(v: Int) { $c = v }
|
||||
var c1: Int = 0; set(v: Int) { $c1 = v }
|
||||
abstract var c2: Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c2 = v }<!>
|
||||
abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { $c3 = v }<!>
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
|
||||
abstract val e2: Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
|
||||
abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
|
||||
|
||||
//methods
|
||||
fun <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>f<!>()
|
||||
fun g() {}
|
||||
abstract fun h()
|
||||
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
|
||||
|
||||
//property accessors
|
||||
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
|
||||
}
|
||||
|
||||
abstract enum class MyAbstractEnum() {}
|
||||
|
||||
namespace MyNamespace {
|
||||
//properties
|
||||
val <!MUST_BE_INITIALIZED!>a<!>: Int
|
||||
val a1: Int = 1
|
||||
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val a2: Int
|
||||
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val a3: Int = 1
|
||||
|
||||
var <!MUST_BE_INITIALIZED!>b<!>: Int private set
|
||||
var b1: Int = 0; private set
|
||||
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var b2: Int private set
|
||||
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var b3: Int = 0; private set
|
||||
|
||||
var <!MUST_BE_INITIALIZED!>c<!>: Int set(v: Int) { $c = v }
|
||||
var c1: Int = 0; set(v: Int) { $c1 = v }
|
||||
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var c2: Int set(v: Int) { $c2 = v }
|
||||
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
|
||||
|
||||
val e: Int get() = a
|
||||
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
|
||||
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val e2: Int get() = a
|
||||
<!ABSTRACT_PROPERTY_NOT_IN_CLASS!>abstract<!> val e3: Int = 0; get() = a
|
||||
|
||||
//methods
|
||||
fun <!NON_MEMBER_FUNCTION_NO_BODY!>f<!>()
|
||||
fun g() {}
|
||||
<!NON_MEMBER_ABSTRACT_FUNCTION!>abstract<!> fun h()
|
||||
<!NON_MEMBER_ABSTRACT_FUNCTION!>abstract<!> fun j() {}
|
||||
|
||||
//property accessors
|
||||
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var <!MUST_BE_INITIALIZED!>k<!>: Int <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
|
||||
|
||||
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
|
||||
}
|
||||
|
||||
//creating an instance
|
||||
abstract class B1(
|
||||
val i: Int,
|
||||
val s: String
|
||||
) {
|
||||
}
|
||||
|
||||
class B2() : B1(1, "r") {}
|
||||
|
||||
abstract class B3(i: Int) {
|
||||
this(): this(1)
|
||||
}
|
||||
|
||||
fun foo(a: B3) {
|
||||
val a = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B3()<!>
|
||||
val b = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B1(2, "s")<!>
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
class NoC {
|
||||
<!ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR!>{
|
||||
|
||||
}<!>
|
||||
|
||||
val a : Int get() = 1
|
||||
|
||||
<!ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR!>{
|
||||
|
||||
}<!>
|
||||
}
|
||||
|
||||
class WithC() {
|
||||
val x : Int
|
||||
{
|
||||
$x = 1
|
||||
<!UNRESOLVED_REFERENCE!>$y<!> = 2
|
||||
val b = x
|
||||
|
||||
}
|
||||
|
||||
val a : Int get() = 1
|
||||
|
||||
{
|
||||
val z = <!UNRESOLVED_REFERENCE!>b<!>
|
||||
val zz = x
|
||||
val zzz = <!NO_BACKING_FIELD!>$a<!>
|
||||
}
|
||||
|
||||
this(a : Int) : this() {
|
||||
val b = x
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
class A() {
|
||||
fun equals(a : Any?) : Boolean = false
|
||||
}
|
||||
|
||||
class B() {
|
||||
fun equals(a : Any?) : Boolean? = false
|
||||
}
|
||||
|
||||
class C() {
|
||||
fun equals(a : Any?) : Int = 0
|
||||
}
|
||||
|
||||
fun f(): Unit {
|
||||
var x: Int? = 1
|
||||
x = 1
|
||||
x <!UNSAFE_INFIX_CALL!>+<!> 1
|
||||
x <!UNSAFE_INFIX_CALL!>plus<!> 1
|
||||
x <!UNSAFE_INFIX_CALL!><<!> 1
|
||||
x <!UNSAFE_INFIX_CALL!>+=<!> 1
|
||||
|
||||
x == 1
|
||||
x != 1
|
||||
|
||||
<!EQUALITY_NOT_APPLICABLE!>A() == 1<!>
|
||||
B() <!RESULT_TYPE_MISMATCH!>==<!> 1
|
||||
C() <!RESULT_TYPE_MISMATCH!>==<!> 1
|
||||
|
||||
<!EQUALITY_NOT_APPLICABLE!>x === "1"<!>
|
||||
<!EQUALITY_NOT_APPLICABLE!>x !== "1"<!>
|
||||
|
||||
x === 1
|
||||
x !== 1
|
||||
|
||||
x<!UNSAFE_INFIX_CALL!>..<!>2
|
||||
<!TYPE_MISMATCH!>x<!> in 1..2
|
||||
|
||||
val y : Boolean? = true
|
||||
false || <!TYPE_MISMATCH!>y<!>
|
||||
<!TYPE_MISMATCH!>y<!> && true
|
||||
<!TYPE_MISMATCH!>y<!> && <!TYPE_MISMATCH!>1<!>
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
namespace boundsWithSubstitutors {
|
||||
open class A<T>
|
||||
class B<X : A<X>>()
|
||||
|
||||
class C : A<C>
|
||||
|
||||
val a = B<C>()
|
||||
val a1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
|
||||
|
||||
class X<A, B : A>()
|
||||
|
||||
val b = X<Any, X<A<C>, C>>
|
||||
val b0 = X<Any, <!UPPER_BOUND_VIOLATED!>Any?<!>>
|
||||
val b1 = X<Any, X<A<C>, <!UPPER_BOUND_VIOLATED!>String<!>>>
|
||||
|
||||
}
|
||||
|
||||
open class A {}
|
||||
open class B<T : A>()
|
||||
|
||||
abstract class C<T : B<<!UPPER_BOUND_VIOLATED!>Int<!>>, X : fun (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) : (B<<!UPPER_BOUND_VIOLATED!>Any<!>>, B<A>)>() : B<<!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any<!>>() { // 2 errors
|
||||
val a = B<<!UPPER_BOUND_VIOLATED!>Char<!>>() // error
|
||||
|
||||
abstract val x : fun (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) : B<<!UPPER_BOUND_VIOLATED!>Any<!>>
|
||||
}
|
||||
|
||||
|
||||
fun test() {
|
||||
foo<<!UPPER_BOUND_VIOLATED!>Int?<!>>()
|
||||
foo<Int>()
|
||||
bar<Int?>()
|
||||
bar<Int>()
|
||||
bar<<!UPPER_BOUND_VIOLATED!>Double?<!>>()
|
||||
bar<<!UPPER_BOUND_VIOLATED!>Double<!>>()
|
||||
1.buzz<<!UPPER_BOUND_VIOLATED!>Double<!>>()
|
||||
}
|
||||
|
||||
fun foo<T : Any>() {}
|
||||
fun bar<T : Int?>() {}
|
||||
fun <T : <!FINAL_UPPER_BOUND!>Int<!>> Int.buzz() : Unit {}
|
||||
@@ -1,85 +0,0 @@
|
||||
class C {
|
||||
|
||||
fun f (a : Boolean, b : Boolean) {
|
||||
@b (while (true)
|
||||
@a {
|
||||
<!NOT_A_LOOP_LABEL!>break@f<!>
|
||||
break
|
||||
break@b
|
||||
<!NOT_A_LOOP_LABEL!>break@a<!>
|
||||
})
|
||||
|
||||
<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue<!>
|
||||
|
||||
@b (while (true)
|
||||
@a {
|
||||
<!NOT_A_LOOP_LABEL!>continue@f<!>
|
||||
continue
|
||||
continue@b
|
||||
<!NOT_A_LOOP_LABEL!>continue@a<!>
|
||||
})
|
||||
|
||||
<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break<!>
|
||||
|
||||
<!NOT_A_LOOP_LABEL!>continue@f<!>
|
||||
<!NOT_A_LOOP_LABEL!>break@f<!>
|
||||
}
|
||||
|
||||
fun containsBreak(a: String?, b: String?) {
|
||||
while (a == null) {
|
||||
break;
|
||||
}
|
||||
a<!UNSAFE_CALL!>.<!>compareTo("2")
|
||||
}
|
||||
|
||||
fun notContainsBreak(a: String?, b: String?) {
|
||||
while (a == null) {
|
||||
while (b == null) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
a.compareTo("2")
|
||||
}
|
||||
|
||||
fun containsBreakWithLabel(a: String?) {
|
||||
@loop while(a == null) {
|
||||
break@loop
|
||||
}
|
||||
a?.compareTo("2")
|
||||
}
|
||||
|
||||
fun containsIllegalBreak(a: String?) {
|
||||
@loop while(a == null) {
|
||||
<!NOT_A_LOOP_LABEL!>break<!UNRESOLVED_REFERENCE!>@label<!><!>
|
||||
}
|
||||
a.compareTo("2")
|
||||
}
|
||||
|
||||
fun containsBreakToOuterLoop(a: String?, b: String?) {
|
||||
@loop while(b == null) {
|
||||
while(a == null) {
|
||||
break@loop
|
||||
}
|
||||
a.compareTo("2")
|
||||
}
|
||||
}
|
||||
|
||||
fun containsBreakInsideLoopWithLabel(a: String?, array: Array<Int>) {
|
||||
@ while(a == null) {
|
||||
for (el in array) {
|
||||
break@
|
||||
}
|
||||
}
|
||||
a<!UNSAFE_CALL!>.<!>compareTo("2")
|
||||
}
|
||||
|
||||
fun unresolvedBreak(a: String?, array: Array<Int>) {
|
||||
while(a == null) {
|
||||
@ for (el in array) {
|
||||
break
|
||||
}
|
||||
if (true) break else <!NOT_A_LOOP_LABEL!>break<!UNRESOLVED_REFERENCE!>@<!><!>
|
||||
}
|
||||
a<!UNSAFE_CALL!>.<!>compareTo("2")
|
||||
}
|
||||
}
|
||||
@@ -1,121 +0,0 @@
|
||||
import java.util.*
|
||||
|
||||
namespace html {
|
||||
|
||||
abstract class Factory<T> {
|
||||
abstract fun create() : T
|
||||
}
|
||||
|
||||
abstract class Element
|
||||
|
||||
class TextElement(val text : String) : Element
|
||||
|
||||
abstract class Tag(val name : String) : Element {
|
||||
val children = ArrayList<Element>()
|
||||
val attributes = HashMap<String, String>()
|
||||
|
||||
protected fun initTag<T : Element>(init : fun T.() : Unit) : T
|
||||
where class object T : Factory<T>{
|
||||
val tag = T.create()
|
||||
tag.init()
|
||||
children.add(tag)
|
||||
return tag
|
||||
}
|
||||
}
|
||||
|
||||
abstract class TagWithText(name : String) : Tag(name) {
|
||||
fun String.plus() {
|
||||
children.add(TextElement(this))
|
||||
}
|
||||
}
|
||||
|
||||
class HTML() : TagWithText("html") {
|
||||
class object : Factory<HTML> {
|
||||
override fun create() = HTML()
|
||||
}
|
||||
|
||||
fun head(init : fun Head.() : Unit) = initTag<Head>(init)
|
||||
|
||||
fun body(init : fun Body.() : Unit) = initTag<Body>(init)
|
||||
}
|
||||
|
||||
class Head() : TagWithText("head") {
|
||||
class object : Factory<Head> {
|
||||
override fun create() = Head()
|
||||
}
|
||||
|
||||
fun title(init : fun Title.() : Unit) = initTag<Title>(init)
|
||||
}
|
||||
|
||||
class Title() : TagWithText("title")
|
||||
|
||||
abstract class BodyTag(name : String) : TagWithText(name) {
|
||||
}
|
||||
|
||||
class Body() : BodyTag("body") {
|
||||
class object : Factory<Body> {
|
||||
override fun create() = Body()
|
||||
}
|
||||
|
||||
fun b(init : fun B.() : Unit) = initTag<B>(init)
|
||||
fun p(init : fun P.() : Unit) = initTag<P>(init)
|
||||
fun h1(init : fun H1.() : Unit) = initTag<H1>(init)
|
||||
fun a(href : String, init : fun A.() : Unit) {
|
||||
val a = initTag<A>(init)
|
||||
a.href = href
|
||||
}
|
||||
}
|
||||
|
||||
class B() : BodyTag("b")
|
||||
class P() : BodyTag("p")
|
||||
class H1() : BodyTag("h1")
|
||||
class A() : BodyTag("a") {
|
||||
var href : String
|
||||
get() = attributes["href"]
|
||||
set(value) { attributes["href"] = value }
|
||||
}
|
||||
|
||||
fun Map<String, String>.set(key : String, value : String) = this.put(key, value)
|
||||
|
||||
fun html(init : fun HTML.() : Unit) : HTML {
|
||||
val html = HTML()
|
||||
html.init()
|
||||
return html
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
namespace foo {
|
||||
|
||||
import html.*
|
||||
|
||||
fun result(args : Array<String>) =
|
||||
html {
|
||||
head {
|
||||
title {+"XML encoding with Groovy"}
|
||||
}
|
||||
body {
|
||||
h1 {+"XML encoding with Groovy"}
|
||||
p {+"this format can be used as an alternative markup to XML"}
|
||||
|
||||
// an element with attributes and text content
|
||||
a(href = "http://groovy.codehaus.org") {+"Groovy"}
|
||||
|
||||
// mixed content
|
||||
p {
|
||||
+"This is some"
|
||||
b {+"mixed"}
|
||||
+"text. For more see the"
|
||||
a(href = "http://groovy.codehaus.org") {+"Groovy"}
|
||||
+"project"
|
||||
}
|
||||
p {+"some text"}
|
||||
|
||||
// content generated by
|
||||
p {
|
||||
for (arg in args)
|
||||
+arg
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
fun test() : Unit {
|
||||
var x : Int? = 0
|
||||
var y : Int = 0
|
||||
|
||||
x : Int?
|
||||
y : Int
|
||||
x as Int : Int
|
||||
y <!USELESS_CAST!>as<!> Int : Int
|
||||
x <!USELESS_CAST!>as<!> Int? : Int?
|
||||
y <!USELESS_CAST_STATIC_ASSERT_IS_FINE!>as<!> Int? : Int?
|
||||
x as? Int : Int?
|
||||
y <!USELESS_CAST!>as?<!> Int : Int?
|
||||
x <!USELESS_CAST!>as?<!> Int? : Int?
|
||||
y <!USELESS_CAST_STATIC_ASSERT_IS_FINE!>as?<!> Int? : Int?
|
||||
()
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
namespace Jet86
|
||||
|
||||
class A {
|
||||
class object {
|
||||
val x = 1
|
||||
}
|
||||
<!MANY_CLASS_OBJECTS!>class object { // error
|
||||
val x = 1
|
||||
}<!>
|
||||
}
|
||||
|
||||
class B() {
|
||||
val x = 12
|
||||
}
|
||||
|
||||
object b {
|
||||
<!CLASS_OBJECT_NOT_ALLOWED!>class object {
|
||||
val x = 1
|
||||
}<!> // error
|
||||
}
|
||||
|
||||
val a = A.x
|
||||
val c = <!NO_CLASS_OBJECT!>B<!>.x
|
||||
val d = b.<!UNRESOLVED_REFERENCE!>x<!>
|
||||
|
||||
val s = <!NO_CLASS_OBJECT!>System<!> // error
|
||||
fun test() {
|
||||
System.out?.println()
|
||||
java.lang.System.out?.println()
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
fun test() {
|
||||
1 : Byte
|
||||
1 : Int
|
||||
<!TYPE_MISMATCH, TYPE_MISMATCH!>1<!> : Double
|
||||
1 <!USELESS_CAST!>as<!> Byte
|
||||
1 <!USELESS_CAST!>as<!> Int
|
||||
<!ERROR_COMPILE_TIME_VALUE!>1<!> <!CAST_NEVER_SUCCEEDS!>as<!> Double
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
open class NoC
|
||||
class NoC1 : NoC
|
||||
|
||||
class WithC0() : NoC<!NO_CONSTRUCTOR!>()<!>
|
||||
open class WithC1() : NoC
|
||||
class NoC2 : <!SUPERTYPE_NOT_INITIALIZED!>WithC1<!>
|
||||
class NoC3 : WithC1<!PRIMARY_CONSTRUCTOR_MISSING_SUPER_CONSTRUCTOR_CALL!>()<!>
|
||||
class WithC2() : <!SUPERTYPE_NOT_INITIALIZED!>WithC1<!>
|
||||
|
||||
class NoPC {
|
||||
<!SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY!>this<!>() {}
|
||||
}
|
||||
|
||||
class WithPC0() {
|
||||
this(a : Int) : this() {}
|
||||
}
|
||||
|
||||
class WithPC1(a : Int) {
|
||||
<!SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST!>this<!>() {}
|
||||
|
||||
this(b : Long) : this("") {}
|
||||
|
||||
this(s : String) : this(1) {}
|
||||
|
||||
this(b : Char) : <!NONE_APPLICABLE!>this<!>("", 2) {}
|
||||
|
||||
this(b : Byte) : this(""), <!MANY_CALLS_TO_THIS!>this(1)<!> {}
|
||||
}
|
||||
|
||||
|
||||
class Foo() : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>WithPC0<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST!>this<!>() {
|
||||
|
||||
}
|
||||
|
||||
class WithCPI_Dup(x : Int) {
|
||||
var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>x<!> : Int
|
||||
}
|
||||
|
||||
class WithCPI(x : Int) {
|
||||
val a = 1
|
||||
val b : Int = $a
|
||||
val xy : Int = x
|
||||
}
|
||||
|
||||
class <!PRIMARY_CONSTRUCTOR_MISSING_STATEFUL_PROPERTY!>NoCPI<!> {
|
||||
val a = <!PROPERTY_INITIALIZER_NO_PRIMARY_CONSTRUCTOR!>1<!>
|
||||
var ab = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1<!>
|
||||
get() = 1
|
||||
set(v) {}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
trait A {
|
||||
fun foo() : Int = 1
|
||||
fun foo1() : Int = 1
|
||||
val a : Int
|
||||
val a1 : Int
|
||||
val <T> g : Iterator<T>
|
||||
|
||||
fun <T> g() : T
|
||||
fun <T> g1() : T
|
||||
}
|
||||
|
||||
abstract class B() : A {
|
||||
override fun <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>foo<!>() {
|
||||
}
|
||||
override fun foo() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Unit<!> {
|
||||
}
|
||||
|
||||
override val a : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Double<!> = 1.dbl
|
||||
override val <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>a1<!> = 1.dbl
|
||||
|
||||
abstract override fun <X> g() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Int<!>
|
||||
abstract override fun <X> g1() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>java.util.List<X><!>
|
||||
|
||||
abstract override val <X> g : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Iterator<Int><!>
|
||||
}
|
||||
|
||||
@@ -1,30 +0,0 @@
|
||||
trait A {
|
||||
fun foo() {}
|
||||
}
|
||||
trait B : A, <!CYCLIC_INHERITANCE_HIERARCHY!>E<!> {}
|
||||
trait C : B {}
|
||||
trait D : <!CYCLIC_INHERITANCE_HIERARCHY!>B<!> {}
|
||||
trait E : <!CYCLIC_INHERITANCE_HIERARCHY!>F<!> {}
|
||||
trait F : <!CYCLIC_INHERITANCE_HIERARCHY!>D<!>, C {}
|
||||
trait G : F {}
|
||||
trait H : F {}
|
||||
|
||||
val a : A? = null
|
||||
val b : B? = null
|
||||
val c : C? = null
|
||||
val d : D? = null
|
||||
val e : E? = null
|
||||
val f : F? = null
|
||||
val g : G? = null
|
||||
val h : H? = null
|
||||
|
||||
fun test() {
|
||||
a?.foo()
|
||||
b?.foo()
|
||||
c?.foo()
|
||||
d?.foo()
|
||||
e?.<!UNRESOLVED_REFERENCE!>foo<!>()
|
||||
f?.foo()
|
||||
g?.foo()
|
||||
h?.foo()
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
enum class List<out T>(val size : Int) {
|
||||
Nil : List<Nothing>(0) {
|
||||
val a = 1
|
||||
}
|
||||
Cons<out T>(val head : T, val tail : List<T>) : List<T>(tail.size + 1)
|
||||
|
||||
}
|
||||
|
||||
val foo = List.Nil
|
||||
val foo1 = foo.a
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user