separate compiler and plugin tests

2011-10-20 16:19:02 +02:00
parent a80398098b
commit ec6dec0d37
586 changed files with 69 additions and 42 deletions
@@ -0,0 +1,5 @@
+namespace foo;
+
+fun main(args : Array<String>) {
+
+}
@@ -0,0 +1,5 @@
+fun f(): Int {
+  var x: Int = 1
+  x = x + 1
+  return x
+}
@@ -0,0 +1,7 @@
+fun main() {
+    var bottles = 99;
+    while(bottles > 0) {
+        System.out?.println("bottles of beer on the wall");
+        bottles--;
+    }
+}
@@ -0,0 +1,7 @@
+fun main() {
+    var bottles = 99;
+    while(bottles > 0) {
+        System.out?.println("bottles of beer on the wall");
+        bottles -= 1;
+    }
+}
@@ -0,0 +1,15 @@
+import java.lang.Integer
+
+open class C {
+    open fun f(): Any = "C f"
+}
+
+class D() : C {
+    override fun f(): String = "D f"
+}
+
+fun box(): String{
+    val d : C = D()
+    if(d.f() != "D f") return "fail f"
+    return "OK"
+}
@@ -0,0 +1,15 @@
+class C(val x: Int) {
+  fun equals(rhs: Any?): Boolean {
+    if (rhs is C) {
+      val rhsC = rhs as C
+      return rhsC.x == x
+    }
+    return false
+  }
+}
+
+fun box(): String {
+  val c1 = C(10)
+  val c2 = C(10)
+  return if (c1 == c2) "OK" else "fail"
+}
@@ -0,0 +1,11 @@
+class C() {
+  class object {
+    fun create() = C()
+  }
+}
+
+fun box(): String {
+  val c = C.create()
+  return if (c is C) "OK" else "fail"
+}
+
@@ -0,0 +1,9 @@
+class C() {
+  fun getInstance(): Runnable = C
+
+  class object: Runnable {
+    override fun run(): Unit { }
+  }
+}
+
+fun foo() = C().getInstance()
@@ -0,0 +1,13 @@
+abstract open class Default {
+  abstract fun defaultValue(): Int
+}
+
+class MyInt() {
+  class object : Default {
+    override fun defaultValue(): Int = 610
+  }
+}
+
+fun toDefault<T: Any>(t: T) where class object T: Default = T.defaultValue()
+
+fun box(): String = if (toDefault<MyInt>(MyInt()) == 610) "OK" else "fail"
@@ -0,0 +1,7 @@
+fun box() : String {
+    return apply( "OK", {(arg: String) => arg } )
+}
+
+fun apply(arg : String, f : fun (p:String) : String) : String {
+    return f(arg)
+}
@@ -0,0 +1,7 @@
+fun box() : String {
+    return if (apply( 5, {(arg: Int) => arg + 13 } ) == 18) "OK" else "fail"
+}
+
+fun apply(arg : Int, f : fun (p:Int) : Int) : Int {
+    return f(arg)
+}
@@ -0,0 +1,24 @@
+// Changed when traits were introduced. May not make sense any more
+
+open class Base() {
+    public var v : Int = 0
+}
+
+open class Left() : Base() {}
+trait Right : Base {}
+
+class D() : Left(), Right
+
+fun vl(l : Left) : Int = l.v
+fun vr(r : Right) : Int = r.v
+
+fun box() : String {
+    val d = D()
+    d.v = 42
+
+    if (d.v != 42) return "Fail #1"
+    if (vl(d) != 42) return "Fail #2"
+    if (vr(d) != 42) return "Fail #3"
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+fun box() : String {
+    val cl = 39
+    return if (sum(200, { val ff = {cl}; ff() }) == 239) "OK" else "FAIL"
+}
+
+fun sum(arg:Int, f : fun () : Int) : Int {
+    return arg + f()
+}
@@ -0,0 +1,8 @@
+fun box() : String {
+    val cl = 39
+    return if (sum(200, { val m = { val r = { cl };  r() }; m() }) == 239) "OK" else "FAIL"
+}
+
+fun sum(arg:Int, f : fun () : Int) : Int {
+    return arg + f()
+}
@@ -0,0 +1,12 @@
+class Point(val x:Int, val y:Int) {
+    fun mul() : fun (scalar:Int):Point  {
+        return { (scalar:Int):Point => Point(x * scalar, y * scalar) }
+    }
+}
+
+val m = Point(2, 3).mul() : fun (scalar:Int):Point
+
+fun box() : String {
+    val answer = m(5)
+    return if (answer.x == 10 && answer.y == 15) "OK" else "FAIL"
+}
@@ -0,0 +1,7 @@
+class GameError(msg: String): Exception(msg) {
+}
+
+fun box(): String {
+  val e = GameError("foo")
+  return if (e.getMessage() == "foo") "OK" else "fail"
+}
@@ -0,0 +1,13 @@
+class Point(val x : Int, val y : Int)
+
+fun box() : String {
+    val answer = apply(Point(3, 5), { Point.(scalar : Int) : Point =>
+        Point(x * scalar, y * scalar)
+    })
+
+    return if (answer.x == 6 && answer.y == 10) "OK" else "FAIL"
+}
+
+fun apply(arg:Point, f : fun Point.(scalar : Int) : Point) : Point {
+    return arg.f(2)
+}
@@ -0,0 +1,17 @@
+open class Base() {
+    fun n(n : Int) : Int = n + 1
+}
+
+trait Abstract {}
+
+class Derived1() : Base(), Abstract {}
+class Derived2() : Abstract, Base() {}
+
+fun test(s : Base) : Boolean = s.n(238) == 239
+
+fun box() : String {
+    if (!test(Base())) return "Fail #1"
+    if (!test(Derived1())) return "Fail #2"
+    if (!test(Derived2())) return "Fail #3"
+    return "OK"
+}
@@ -0,0 +1,41 @@
+// Changed when traits were introduced. May not make sense any more
+
+open class X(val x : Int) {}
+trait Y {
+    abstract val y : Int
+}
+
+class YImpl(override val y : Int) : Y {}
+
+class Point(x : Int, yy : Int) : X(x) , Y {
+    override val y : Int = yy
+}
+
+trait Abstract {}
+
+class P1(x : Int, yy : Y) : Abstract, X(x), Y by yy {}
+class P2(x : Int, yy : Y) : X(x), Abstract, Y by yy {}
+class P3(x : Int, yy : Y) : X(x), Y by yy, Abstract {}
+class P4(x : Int, yy : Y) : Y by yy, Abstract, X(x) {}
+
+fun box() : String {
+    if (X(239).x != 239) return "FAIL #1"
+    if (YImpl(239).y != 239) return "FAIL #2"
+
+    val p = Point(240, -1)
+    if (p.x + p.y != 239) return "FAIL #3"
+
+    val y = YImpl(-1)
+    val p1 = P1(240, y)
+    if (p1.x + p1.y != 239) return "FAIL #4"
+    val p2 = P2(240, y)
+    if (p2.x + p2.y != 239) return "FAIL #5"
+
+    val p3 = P3(240, y)
+    if (p3.x + p3.y != 239) return "FAIL #6"
+
+    val p4 = P4(240, y)
+    if (p4.x + p4.y != 239) return "FAIL #7"
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+class Outer() {
+  open class InnerBase() {
+  }
+
+  class InnerDerived(): InnerBase() {
+  }
+
+  public val foo: InnerBase? = InnerDerived()
+}
+
+fun box() : String {
+  val o = Outer()
+  return if (o.foo === null) "fail" else "OK"
+}
@@ -0,0 +1,13 @@
+open class Foo {
+  fun xyzzy(): String = "xyzzy"
+}
+
+class Bar(): Foo {
+  fun test(): String = xyzzy()
+}
+
+fun box() : String {
+  val bar = Bar()
+  val f = bar.test()
+  return if (f == "xyzzy") "OK" else "fail"
+}
@@ -0,0 +1 @@
+class Foo() : java.util.ArrayList<Int>()
@@ -0,0 +1,13 @@
+class C() {
+  public var f: Int
+
+  {
+    $f = 610
+  }
+}
+
+fun box(): String {
+  val c = C()
+  if (c.f != 610) return "fail"
+  return "OK"
+}
@@ -0,0 +1,20 @@
+import java.util.*
+import java.io.*
+
+class World() {
+  public val items: ArrayList<Item> = ArrayList<Item>
+
+  class Item() {
+    {
+      items.add(this)
+    }
+  }
+
+  val foo = Item()
+}
+
+fun box() : String {
+  val w = World()
+  if (w.items.size() != 1) return "fail"
+  return "OK"
+}
@@ -0,0 +1,19 @@
+class Outer(val foo: StringBuilder) {
+  class Inner() {
+    fun len() : Int {
+      return foo.length()
+    }
+  }
+
+  fun test() : Inner {
+    return Inner()
+  }
+}
+
+fun box() : String {
+  val sb = StringBuilder("xyzzy")
+  val o = Outer(sb)
+  val i = o.test()
+  val l = i.len()
+  return if (l != 5) "fail" else "OK"
+}
@@ -0,0 +1,8 @@
+class SimpleClass() {
+    fun foo() = 610
+}
+
+fun test() : Int {
+  val c = SimpleClass()
+  return c.foo()
+}
@@ -0,0 +1,12 @@
+class Outer() {
+  class Inner() {
+    val outer: Outer get() = this@Outer
+  }
+
+  public val x : Inner = Inner()
+}
+
+fun box() : String {
+  val o = Outer()
+  return if (o === o.x.outer) "OK" else "fail"
+}
@@ -0,0 +1,25 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+       contents.add(item)
+    }
+
+    fun plus(b: ArrayWrapper<T>): ArrayWrapper<T> {
+        val result = ArrayWrapper<T>()
+        result.contents.addAll(contents)
+        result.contents.addAll(b.contents)
+        return result
+    }
+}
+
+fun box(): String {
+    val v1 = ArrayWrapper<String>()
+    val v2 = ArrayWrapper<String>()
+    v1.add("foo")
+    v2.add("bar")
+    val v3 = v1 + v2
+    return if (v3.contents.size() == 2) "OK" else "fail"
+}
@@ -0,0 +1,26 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+        contents.add(item)
+    }
+
+    fun plusAssign(rhs: ArrayWrapper<T>) {
+        contents.addAll(rhs.contents)
+    }
+
+    fun get(index: Int): T {
+        return contents.get(index)
+    }
+}
+
+fun box(): String {
+    val v1 = ArrayWrapper<String>()
+    val v2 = ArrayWrapper<String>()
+    v1.add("foo")
+    v2.add("bar")
+    v1 += v2
+    return if (v1.contents.size() == 2) "OK" else "fail"
+}
@@ -0,0 +1,30 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+        contents.add(item)
+    }
+
+    fun plusAssign(rhs: ArrayWrapper<T>): ArrayWrapper<T> {
+        val result = ArrayWrapper<T>()
+        result.contents.addAll(contents)
+        result.contents.addAll(rhs.contents)
+        return result
+    }
+
+    fun get(index: Int): T {
+        return contents.get(index)
+    }
+}
+
+fun box(): String {
+    val v1 = ArrayWrapper<String>()
+    val v2 = ArrayWrapper<String>()
+    v1.add("foo")
+    val v3 = v1
+    v2.add("bar")
+    v1 += v2
+    return if (v1.contents.size() == 2 && v3.contents.size() == 1) "OK" else "fail"
+}
@@ -0,0 +1,30 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+        contents.add(item)
+    }
+
+    fun plus(rhs: ArrayWrapper<T>): ArrayWrapper<T> {
+        val result = ArrayWrapper<T>()
+        result.contents.addAll(contents)
+        result.contents.addAll(rhs.contents)
+        return result
+    }
+
+    fun get(index: Int): T {
+        return contents.get(index)
+    }
+}
+
+fun box(): String {
+    val v1 = ArrayWrapper<String>()
+    val v2 = ArrayWrapper<String>()
+    v1.add("foo")
+    val v3 = v1
+    v2.add("bar")
+    v1 += v2
+    return if (v1.contents.size() == 2 && v3.contents.size() == 1) "OK" else "fail"
+}
@@ -0,0 +1,28 @@
+import java.util.*
+
+class ArrayWrapper<T>() {
+    val contents = ArrayList<T>()
+
+    fun add(item: T) {
+       contents.add(item)
+    }
+
+    fun minus(): ArrayWrapper<T> {
+        val result = ArrayWrapper<T>()
+        result.contents.addAll(contents)
+        Collections.reverse(result.contents)
+        return result
+    }
+
+    fun get(index: Int): T {
+        return contents.get(index)
+    }
+}
+
+fun box(): String {
+    val v1 = ArrayWrapper<String>()
+    v1.add("foo")
+    v1.add("bar")
+    val v2 = -v1
+    return if (v2[0] == "bar" && v2[1] == "foo") "OK" else "fail"
+}
@@ -0,0 +1,33 @@
+open class Base() {
+    val plain = 239
+    public val read : Int
+      get() = 239
+
+    public var readwrite : Int = 0
+      get() = $readwrite + 1
+      set(n : Int) {
+        $readwrite = n
+      }
+}
+
+trait Abstract {}
+
+class Derived1() : Base(), Abstract {}
+class Derived2() : Abstract, Base() {}
+
+fun code(s : Base) : Int {
+    if (s.plain != 239) return 1
+    if (s.read != 239) return 2
+    s.readwrite = 238
+    if (s.readwrite != 239) return 3
+    return 0
+}
+
+fun test(s : Base) : Boolean = code(s) == 0
+
+fun box() : String {
+    if (!test(Base())) return "Fail #1"
+    if (!test(Derived1())) return "Fail #2"
+    if (!test(Derived2())) return "Fail #3"
+    return "OK"
+}
@@ -0,0 +1,16 @@
+class Outer() {
+  val s = "xyzzy"
+
+  open class InnerBase(public val name: String) {
+  }
+
+  class InnerDerived(): InnerBase(s) {
+  }
+
+  val x = InnerDerived()
+}
+
+fun box() : String {
+  val o = Outer()
+  return if (o.x.name != "xyzzy") "fail" else "OK"
+}
@@ -0,0 +1,20 @@
+// Changed when traits were introduced. May not make sense any more
+
+trait Left {}
+open class Right() {
+    open fun f() = 42
+}
+
+class D() : Left, Right() {
+    override fun f() = 239
+}
+
+fun box() : String {
+    val r : Right = Right()
+    val d : D = D()
+
+    if (r.f() != 42) return "Fail #1"
+    if (d.f() != 239) return "Fail #2"
+
+    return "OK"
+}
@@ -0,0 +1,8 @@
+class C(val n: Int, val s: String) {
+  this(n: Int): this(n, "foo") { }
+}
+
+fun box(): String {
+  val c = C(10)
+  return if (c.s == "foo") "OK" else "fail"
+}
@@ -0,0 +1,8 @@
+class Box<T>(t: T) {
+    var value = t
+}
+
+fun box(): String {
+    val box: Box<Int> = Box<Int>(1)
+    return if (box.value == 1) "OK" else "fail"
+}
@@ -0,0 +1,5 @@
+class SimpleClass {
+    fun foo() : Int {
+      return 0;
+    }
+}
@@ -0,0 +1,7 @@
+fun box() : String {
+    return invoker( {"OK"} )
+}
+
+fun invoker(gen : fun () : String) : String {
+    return gen()
+}
@@ -0,0 +1,7 @@
+fun box() : String {
+    return if (int_invoker( { 7 } ) == 7) "OK" else "fail"
+}
+
+fun int_invoker(gen : fun () : Int) : Int {
+    return gen()
+}
@@ -0,0 +1,10 @@
+fun fac(i: Int): Int {
+    var count = 1;
+    var result = 1;
+    while(true) {
+        count = count + 1;
+        result = result * count;
+        if (count == i) break;
+    }
+    return result;
+}
@@ -0,0 +1,10 @@
+fun continue_test(i: Int): Int {
+  var count = i;
+  var result = 0;
+  while(count > 0) {
+    count = count - 1;
+    if (count <= 2) continue;
+    result = result + count;
+  }
+  return result;
+}
@@ -0,0 +1,9 @@
+fun fac(i: Int): Int {
+    var count = 1;
+    var result = 1;
+    do {
+        count = count + 1;
+        result = result * count;
+    } while(count != i);
+    return result;
+}
@@ -0,0 +1,9 @@
+import java.util.*
+
+fun concat(l: List<String>): String? {
+  val sb = StringBuilder()
+  for(s in l) {
+    sb.append(s)
+  }
+  return sb.toString()
+}
@@ -0,0 +1,7 @@
+fun concat(l: Array<String>): String? {
+  val sb = StringBuilder()
+  for(s in l) {
+    sb.append(s)
+  }
+  return sb.toString()
+}
@@ -0,0 +1,14 @@
+fun box() : String {
+    val a = Array<Int> (5, {0})
+    var i = 0
+    var sum = 0
+    for(el in 0..4) {
+       a[i] = i++
+    }
+    for (el in a) {
+        sum = sum + el
+    }
+    if(sum != 10) return "a failed"
+
+    return "OK"
+}
@@ -0,0 +1,13 @@
+fun box() : String {
+    val a = Array<String?>(3)
+    a[0] = "a"
+    a[1] = "b"
+    a[2] = "c"
+
+    val result = 0
+    for(i in a.indices) {
+      result += i
+    }
+    if (result != 3) return "FAIL"
+    return "OK"
+}
@@ -0,0 +1,16 @@
+fun box() : String {
+    val b : Array<Int?> = Array<Int?> (5)
+    var i = 0
+    var sum = 0
+    while(i < 5) {
+       b[i] = i++
+    }
+    sum = 0
+    for (el in b) {
+        sum = sum + (el ?: 0)
+    }
+    System.out?.println(sum)
+    if(sum != 10) return "b failed"
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+fun box() : String {
+    val a = IntArray (5)
+    var i = 0
+    var sum = 0
+    for(el in 0..4) {
+       a[i] = i++
+    }
+    for (el in a) {
+        sum = sum + el
+    }
+    if(sum != 10) return "a failed"
+
+    return "OK"
+}
@@ -0,0 +1,115 @@
+fun box() : String {
+    var sum : Int = 0
+    var i = 0
+
+    val c6 = MyCollection4()
+    sum = 0
+    for (el in c6) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c6 failed"
+
+    val c5 = MyCollection3()
+    sum = 0
+    for (el in c5) {
+        sum = sum + (el ?: 0)
+    }
+    if(sum != 15) return "c5 failed"
+
+    val c1: java.lang.Iterable<Int> = MyCollection1()
+    sum = 0
+    for (el in c1) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c1 failed"
+
+    val c2 = MyCollection1()
+    sum = 0
+    for (el in c2) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c2 failed"
+
+    val c3: Iterable<Int> = MyCollection2()
+    sum = 0
+    for (el in c3) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c3 failed"
+
+    val c4 = MyCollection2()
+    sum = 0
+    for (el in c4) {
+        sum = sum + el
+    }
+    if(sum != 15) return "c4 failed"
+
+    val a : Array<Int> = Array<Int> (5, {0})
+    for(el in 0..4) {
+       a[i] = i++
+    }
+    sum = 0
+    for (el in a) {
+        sum = sum + el
+    }
+    if(sum != 10) return "a failed"
+
+    val b : Array<Int?> = Array<Int?> (5)
+    i = 0
+    while(i < 5) {
+       b[i] = i++
+    }
+    sum = 0
+    for (el in b) {
+        sum = sum + (el ?: 0)
+    }
+    System.out?.println(sum)
+    if(sum != 10) return "b failed"
+
+    return "OK"
+}
+
+class MyCollection1(): java.lang.Iterable<Int> {
+    override fun iterator(): java.util.Iterator<Int> = MyIterator()
+
+    class MyIterator(): java.util.Iterator<Int> {
+        var k : Int = 5
+
+        override fun next() : Int = k--
+        override fun hasNext() = k > 0
+        override fun remove() {}
+    }
+}
+
+class MyCollection2(): Iterable<Int> {
+    override fun iterator(): Iterator<Int> = MyIterator()
+
+    class MyIterator(): Iterator<Int> {
+        var k : Int = 5
+
+        override fun next() : Int = k--
+        override fun hasNext() = k > 0
+    }
+}
+
+class MyCollection3() {
+    fun iterator() = MyIterator()
+
+    class MyIterator() {
+        var k : Int = 5
+
+        fun next() : Int? = k--
+        fun hasNext() = k > 0
+    }
+}
+
+class MyCollection4() {
+    fun iterator() = MyIterator()
+
+    class MyIterator() {
+        var k : Int = 5
+
+        fun next() : Int = k--
+        fun hasNext() = k > 0
+    }
+}
@@ -0,0 +1 @@
+fun foo(b: Boolean): Int { return if (b) 15 else 20 }
@@ -0,0 +1,10 @@
+import java.util.*
+
+fun concat(l: List<String>): String? {
+    val sb = StringBuilder()
+    for(s in l) {
+        val x = if(l.size() > 1) { "T" } else { "F" };
+        sb.append(x)
+    }
+    return sb.toString()
+}
@@ -0,0 +1,5 @@
+fun f(x: Int, b: Boolean): Int {
+  var result = x;
+  if (b) else result = result + 5;
+  return result;
+}
@@ -0,0 +1,4 @@
+fun foo(b: Boolean) : Int {
+  if (b) return 15;
+  return 20;
+}
@@ -0,0 +1,9 @@
+fun foo(s: String): String? {
+  try {
+    Integer.parseInt(s);
+    return "no message";
+  }
+  catch(e: NumberFormatException) {
+    return (e : Throwable).getMessage(); // Work around an overload-resolution bug
+  }
+}
@@ -0,0 +1,9 @@
+fun f(sb: StringBuilder, s: String): Unit {
+  try {
+    sb.append("foo");
+    sb.append(Integer.parseInt(s));
+  }
+  finally {
+    sb.append("bar");
+  }
+}
@@ -0,0 +1,9 @@
+fun fac(i: Int): Int {
+    var count = 1;
+    var result = 1;
+    while(count < i) {
+        count = count + 1;
+        result = result * count;
+    }
+    return result;
+}
@@ -0,0 +1,21 @@
+import java.util.*
+
+fun <T> ArrayList<T>.findAll(predicate: fun (T) : Boolean): ArrayList<T> {
+  val result = ArrayList<T>()
+  for(val t in this) {
+    if (predicate(t)) result.add(t)
+  }
+  return result
+}
+
+
+fun box(): String {
+  val list: ArrayList<String> = ArrayList<String>()
+  list.add("Prague")
+  list.add("St.Petersburg")
+  list.add("Moscow")
+  list.add("Munich")
+
+  val m: ArrayList<String> = list.findAll<String>({(name: String) => name.startsWith("M")})
+  return if (m.size() == 2) "OK" else "fail"
+}
@@ -0,0 +1,3 @@
+fun StringBuilder.first() = this.charAt(0)
+
+fun foo() = StringBuilder("foo").first()
@@ -0,0 +1,14 @@
+fun StringBuilder.takeFirst(): Char {
+  if (this.length() == 0) return 0.chr
+  val c = this.charAt(0)
+  this.deleteCharAt(0)
+  return c
+}
+
+fun foo(expr: StringBuilder): Int {
+  val c = expr.takeFirst()
+  when(c) {
+    0.chr => throw Exception("zero")
+    else => throw Exception("nonzero" + c)
+  }
+}
@@ -0,0 +1,9 @@
+fun f() : String? {
+  val x = StringBuilder();
+  g(x);
+  return x.toString();
+}
+
+fun g(sb: StringBuilder): Unit {
+  sb.append("foo");
+}
@@ -0,0 +1,63 @@
+fun reformat(
+  str : String,
+  normalizeCase : Boolean = true,
+  uppercaseFirstLetter : Boolean = true,
+  divideByCamelHumps : Boolean = true,
+  wordSeparator : String = " "
+) =
+  (normalizeCase, uppercaseFirstLetter, divideByCamelHumps, wordSeparator)
+
+trait A {
+    fun bar2(arg: Int = 239) : Int
+
+    fun bar(arg: Int = 240) : Int = bar2(arg/2)
+}
+
+open abstract class B() : A, java.lang.Object() {
+    fun foo(arg: Int = 239 + 1) : Int = arg
+
+    abstract fun foo2(arg: Int = 239) : Int
+
+    override fun bar2(arg: Int) : Int = arg
+}
+
+class C() : B() {
+    override fun foo2(arg: Int) : Int = arg
+
+    fun Any.toMyPrefixedString(prefix: String = "", suffix: String="") : String = prefix + " " + suffix
+
+    fun testReceiver() : String {
+        val res : String = "mama".toMyPrefixedString("111", "222")
+        System.out?.println(res)
+        return res
+    }
+
+    override fun toString() : String = "CCC"
+}
+
+fun <T> T.toPrefixedString(prefix: String = "", suffix: String="") = prefix + (this as java.lang.Object).toString() + suffix
+
+fun box() : String {
+    val expected = (true, true, true, " ")
+
+    if("mama".toPrefixedString(suffix="321", prefix="papa") != "papamama321") return "fail"
+    if("mama".toPrefixedString(prefix="papa") != "papamama") return "fail"
+    if("mama".toPrefixedString("papa", "239") != "papamama239") return "fail"
+    if("mama".toPrefixedString("papa") != "papamama") return "fail"
+    if("mama".toPrefixedString() != "mama") return "fail"
+    if(C().testReceiver() != "111 222") return "fail"
+    if(C().bar(10) != 5) return "fail"
+    if(C().bar() != 120) return "fail"
+    if(C().foo(10) != 10) return "fail"
+    if(C().foo() != 240) return "fail"
+    if(C().foo2() != 239) return "fail"
+    if(C().foo2(10) != 10) return "fail"
+    if(C().bar2() != 239) return "fail"
+    if(C().bar2(10) != 10) return "fail"
+    if(reformat("", true, true, true, " ") != expected) return "fail"
+    if(reformat("", true, true, true) != expected) return "fail"
+    if(reformat("", true, true) != expected) return "fail"
+    if(reformat("", true) != expected) return "fail"
+    if(reformat("") != expected) return "fail"
+    return "OK"
+}
@@ -0,0 +1,13 @@
+fun loop(times : Int) {
+   while(times > 0) {
+        val u : fun(value : Int) : Unit = {
+            System.out?.println(it)
+        }
+        u(times--)
+   }
+}
+
+fun box() : String {
+    loop(5)
+    return "OK"
+}
@@ -0,0 +1 @@
+fun f() { System.out?.println("Hello World"); }
@@ -0,0 +1,14 @@
+class Slot() {
+  var vitality: Int = 10000
+
+  fun increaseVitality(delta: Int) {
+    vitality += delta
+    if (vitality > 65535) vitality = 65535;
+  }
+}
+
+fun box(): String {
+  val s = Slot()
+  s.increaseVitality(1000)
+  return if (s.vitality == 11000) "OK" else "fail"
+}
@@ -0,0 +1,6 @@
+fun f(a:Int) : Int {
+   val x = 42
+   val y = 50
+
+   return y
+}
@@ -0,0 +1,7 @@
+namespace Foo {
+  fun bar() = 610
+}
+
+fun box(): String {
+  return if (Foo.bar() == 610) "OK" else "fail"
+}
@@ -0,0 +1,10 @@
+class SimpleClass {
+    this() {}
+
+    fun foo() = 610
+}
+
+fun test() {
+  val c = SimpleClass()
+  return c.foo()
+}
@@ -0,0 +1,5 @@
+object A {
+  fun result() = "OK"
+}
+
+fun box(): String = A.result()
@@ -0,0 +1,17 @@
+class C(x: Int, val y : Int) {
+  fun initChild(x: Int) : java.lang.Object {
+    return object : java.lang.Object() {
+      override fun toString(): String? {
+          x = x + y
+          return "child" + x
+      }
+    }
+  }
+
+  val child = initChild(x)
+}
+
+fun box(): String {
+  val c = C(10,3)
+  return if (c.child.toString() == "child13" && c.child.toString() == "child16" && c.child.toString() == "child19") "OK" else "fail"
+}
@@ -0,0 +1,7 @@
+object A {
+  val x: Int = 610
+}
+
+fun box() : String {
+  return if (A.x != 610) "fail" else "OK"
+}
@@ -0,0 +1,9 @@
+class C(val p: Boolean) { }
+
+fun box(): String {
+  val c = C(true)
+  return when(c) {
+    .p => "OK"
+    else => "fail"
+  }
+}
@@ -0,0 +1,4 @@
+fun isZero(x: Int) = when(x) {
+  0 => true
+  else => false
+}
@@ -0,0 +1,3 @@
+fun isZero(x: Int) = when(x) {
+  0 => true
+}
@@ -0,0 +1,9 @@
+fun isDigit(a: Int) : String {
+    val aa = java.util.ArrayList<Int> ()
+    aa.add(239)
+
+    if(a in aa) return "array list"
+    if(a in 0..9)  return "digit"
+    if(a !in 0..100) return "not small"
+    return "something"
+}
@@ -0,0 +1,11 @@
+fun typeName(a: Any?) : String {
+    return when(a) {
+        is java.util.ArrayList<Int> => "array list"
+        else => "no idea"
+    }
+}
+
+fun box() : String {
+    if(typeName(java.util.ArrayList<Int> ()) != "array list") return "array list failed"
+    return "OK"
+}
@@ -0,0 +1,4 @@
+fun isString(x: Any) = when(x) {
+  is String => "string"
+  else => "something"
+}
@@ -0,0 +1,11 @@
+fun isDigit(a: Int) : String {
+    val aa = java.util.ArrayList<Int> ()
+    aa.add(239)
+
+    return when(a) {
+      in aa => "array list"
+      in 0..9 => "digit"
+     !in 0..100 => "not small"
+      else => "something"
+    }
+}
@@ -0,0 +1,4 @@
+fun isDigit(a: Char) = when(a) {
+  in '0'..'9' => "digit"
+  else => "something"
+}
@@ -0,0 +1,5 @@
+private var x = 0;
+
+fun increment(): Int {
+  return ++x;
+}
@@ -0,0 +1,7 @@
+var collector: String = ""
+  set(it) { $collector = $collector + it }
+
+fun append(s: String): String {
+  collector = s;
+  return collector;
+}
@@ -0,0 +1,7 @@
+var collector: String = ""
+  set(it) { $collector += it }
+
+fun append(s: String): String {
+  collector = s;
+  return collector;
+}
@@ -0,0 +1,3 @@
+class PrivateVal() {
+  private val prop = 0;
+}
@@ -0,0 +1,6 @@
+class PrivateVar() {
+  private var x = 0;
+
+  fun setValueOfX(aValue: Int) { x = aValue }
+  fun getValueOfX() = x
+}
@@ -0,0 +1,6 @@
+class Evaluator(val expr: StringBuilder) {
+  fun evaluateArg(): Int {
+    return expr.length()
+  }
+}
+
@@ -0,0 +1,10 @@
+class A() {
+    fun foo() {
+        System.out?.println(1)
+    }
+}
+
+fun box() : String {
+    val a : A = A()
+    return "OK"
+}
@@ -0,0 +1,41 @@
+fun main(args: Array<String>?) {
+    val y: Unit = () //do not compile
+    A<Unit>()        //do not compile
+    C<Unit>(())      //do not compile
+        //do not compile
+    System.out?.println(fff<Unit>(()))  //do not compile
+    System.out?.println(id<Unit>(y))  //do not compile
+    System.out?.println(fff<Unit>(id<Unit>(y)) == id<Unit>(foreach(Array<Int>(0,{0}),{(e : Int) : Unit => })))  //do not compile
+}
+class A<T>()
+
+class C<T>(val value: T) {
+    fun foo(): T = value
+}
+
+fun <T> fff(x: T) : T { return x }
+
+fun <T> id(value: T): T = value
+
+fun foreach(array: Array<Int>?, action: fun(Int): Unit) {
+    for (el in array) {
+       action(el) //exception through compilation (see below)
+    }
+}
+
+fun almostFilter(array: Array<Int>, action: fun(Int): Int) {
+    for (el in array) {
+       action(el)
+    }
+}
+
+fun box() : String {
+    val a = Array<Int> (3,{-1})
+    a[0] = 0
+    a[1] = 1
+    a[2] = 2
+    foreach(a, { (el : Int) : Unit => System.out?.println(el) })
+    almostFilter(a, { (el : Int) : Int => el })
+    main(null)
+    return "OK"
+}
@@ -0,0 +1,58 @@
+fun t1 () {
+    val a1 = Array<String?>(1)
+    a1[0] = "0" //ok
+    val s = a1[0] //ok
+}
+
+fun t2 () {
+    val a2 = Array<Int>(1,{0})
+    a2[0] = 0 //ok
+    var i = a2[0] //ok
+}
+
+fun t3 () {
+    val a3 = Array<Int?>(1)
+    a3[0] = 0 //verify error
+    var j = a3[0] //ok
+    var k : Int = a3[0] ?: 5 //ok
+}
+
+fun t4 () {
+    val b1 = StrangeIntArray(10)
+    b1[4] = 5 //ok
+    var i = b1[1] //ok
+}
+
+fun t5 () {
+    val b2 = StrangeArray<Int>(10, 0)
+    b2.set(4, 5) //ok
+    b2[4] = 5 //verify error
+    var i = b2.get(2) //ok
+    i = b2[1] //verify error
+}
+
+fun t6() {
+    val b3 = StrangeArray<Int?>(10, 0)
+    b3.set(5, 6) //ok
+    b3[4] = 5 //verify error
+    val v = b3[1] //ok
+}
+
+fun box() : String {
+    return "OK"
+}
+
+class StrangeArray<T>(size: Int, private var defaultValue: T) {
+    fun get(index: Int): T = defaultValue
+    fun set(index: Int, v: T) {
+        defaultValue = v
+    }
+}
+
+class StrangeIntArray(size: Int) {
+    private var defaultValue = 0
+    fun get(index: Int): Int = defaultValue
+    fun set(index: Int, v: Int) {
+        defaultValue = v
+    }
+}
@@ -0,0 +1,3 @@
+fun box(i: Int?) {
+    val j = i?.plus(3) //verify error
+}
@@ -0,0 +1,19 @@
+fun box() : String {
+    val i: Int? = 7
+    val j: Int? = null
+    val k = 7
+
+    //verify errors
+    if (i == 7) {}
+    if (7 == i) {}
+
+    if (j == 7) {}
+    if (7 == j) {}
+
+    if (i == k) {}
+    if (k == i) {}
+
+    if (j == k) {}
+    if (k == j) {}
+    return "OK"
+}
@@ -0,0 +1,8 @@
+fun box() : String {
+    val t = java.lang.String.copyValueOf(java.lang.String("s").toCharArray())
+    val i = java.lang.Integer.MAX_VALUE
+    val j = java.lang.Integer.valueOf(15)
+    val s = java.lang.String.valueOf(1)
+    val l = java.util.Collections.emptyList<Int>()
+    return "OK"
+}
@@ -0,0 +1,32 @@
+fun foo() {
+    val l = java.util.ArrayList<Int>(2)
+    l.add(1)
+
+    for (el in l) {}
+
+    //verify error "Expecting to find integer on stack"
+    val iterator = l.iterator()
+
+    //another verify error "Mismatched stack types"
+    while (iterator?.hasNext() ?: false) {
+        val i = iterator?.next()
+    }
+
+    //the same
+    if (iterator != null) {
+        while (iterator.hasNext()) {
+            val i = iterator?.next()
+        }
+    }
+
+    //this way it works
+    if (iterator != null) {
+        while (iterator.hasNext()) {
+            iterator.next() //because of the bug KT-244 i can't write "val i = iterator.next()"
+        }
+    }
+}
+
+fun box() : String {
+    return "OK"
+}
@@ -0,0 +1,38 @@
+fun t1() : Boolean {
+    val s1 : String? = "sff"
+    val s2 : String? = null
+    return s1?.length == 3 && s2?.length == null
+}
+
+fun t2() : Boolean {
+    val c1: C? = C(1)
+    val c2: C? = null
+    return c1?.x == 1 && c2?.x == null
+}
+
+fun t3() {
+    val d: D = D("s")
+    System.out?.println(d?.s)
+    System.out?.println(d?.s == "s") //prints true
+    System.out?.println(d)    //ok
+}
+
+fun t4() {
+    val e: E? = E()
+    System.out?.println(e?.foo() == e) //verify error
+    System.out?.println(e?.foo())  //verify error
+}
+
+fun box() : String {
+    if(!t1 ()) return "fail"
+    if(!t2 ()) return "fail"
+    t3()
+    t4()
+    return "OK"
+}
+
+class C(val x: Int)
+class D(val s: String)
+class E() {
+    fun foo() = 1
+}
@@ -0,0 +1,7 @@
+fun box() : String {
+    val b = true as? Boolean //exception
+    val i = 1 as Int         //exception
+    val j = 1 as Int?        //ok
+    val s = "s" as String    //ok
+    return "OK"
+}
@@ -0,0 +1,35 @@
+namespace x
+
+class Outer(val name: String) {
+    class Inner() {
+        val me = name
+
+        class object {
+           fun bar() = "bar"
+        }
+    }
+
+    class object {
+        class StaticInner() {
+            class object {
+                fun f() = "oo"
+            }
+        }
+    }
+}
+
+fun box (): String {
+    val inner  = Outer("mama").Inner() //verify error
+    if(inner.me != "mama")
+        return "fail"
+
+    val outer = Outer ("papa")
+    val inner2 = outer.Inner ()
+    if(inner2.me != "papa")
+        return "fail"
+
+    if(Outer.StaticInner.f() != "oo" )
+        return "fail"
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+class A<T>(var t: T) {}
+class B<R>(val r: R) {}
+
+fun box() : String {
+    val ai = A<Int>(1)
+    val aai = A<A<Int>>(ai)
+    if(aai.t.t != 1)  return "fail"
+/*
+    aai.t.t = 2
+    if(aai.t.t != 2)  return "fail"
+
+    if(ai.t != 2)  return "fail"
+    if(aai.t != ai)  return "fail"
+    if(aai.t !== ai) return "fail"
+
+    val abi = A<B<Int>>(B<Int>(1))
+    if(abi.t.r != 1) return "fail"
+*/
+    return "OK"
+}
@@ -0,0 +1,251 @@
+class A() {}
+open class B<T>() {
+    fun isT (a : Any?) : Boolean {
+        return a is T
+    }
+}
+
+class C() : B<String>() {
+}
+
+class D<T>() : B<B<T>>() {
+}
+
+fun t1() : Boolean {
+    val a = A()
+    if(a !is A)   return false
+    return true
+}
+
+fun t2() : Boolean {
+    val a = A()
+    if(a !is A?)   return false
+    return true
+}
+
+fun t3() : Boolean {
+    val a = A()
+    if(null !is A?)   return false
+    return true
+}
+
+fun t4 () : Boolean {
+    val b = B<String>()
+    if(b !is B<String>)   return false
+    return true
+}
+
+fun t5 () : Boolean {
+    val b = B<String>()
+    if(b !is B<String>?)  return false
+    return true
+}
+
+fun t6 () : Boolean {
+    if(null !is B<String>?)  return false
+    return true
+}
+
+fun t7 () : Boolean {
+    val b = B<String>()
+    if(!b.isT("aaa")) return false
+    return true
+}
+
+fun t8 () : Boolean {
+    val b = B<String>()
+    if(b.isT(10))     return false
+    return true
+}
+
+fun t9 () : Boolean {
+    val b = B<String>()
+    if(b.isT(null))   return false
+    return true
+}
+
+fun t10 () : Boolean {
+    val d = B<String?>()
+    if(!d.isT("aaa")) return false
+    return true
+}
+fun t11 () : Boolean {
+    val d = B<String?>()
+    if(d.isT(10))     return false
+    return true
+}
+
+fun t12 () : Boolean {
+    val d = B<String?>()
+    if(!d.isT(null))  return false
+    return true
+}
+
+fun t13 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(!f.isT("aaa")) return false
+    return true
+}
+
+fun t14 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(f.isT(10))     return false
+    return true
+}
+
+fun t15 () : Boolean {
+    val f = B<java.lang.String?>()
+    if(!f.isT(null))  return false
+    return true
+}
+
+fun t16 () : Boolean {
+    val c = B<Int>()
+    if(c.isT("aaa")) return false
+    return true
+}
+
+fun t17 () : Boolean {
+    val c = B<Int>()
+    if(!c.isT(10))   return false
+    return true
+}
+
+fun t18 () : Boolean {
+    val c = B<Int>()
+    if(c.isT(null)) return false
+    return true
+}
+
+fun t19 () : Boolean {
+    val e = B<Int?>()
+    if(e.isT("aaa")) return false
+    return true
+}
+
+fun t20 () : Boolean {
+    val e = B<Int?>()
+    if(!e.isT(10))   return false
+    return true
+}
+
+fun t21 () : Boolean {
+    val e = B<Int?>()
+    if(!e.isT(null)) return false
+    return true
+}
+
+fun t22 () : Boolean {
+    val b = B<String>()
+    val w : B<String>? = b as B<String>   //ok
+    val x = w as B<String>?  //TypeCastException
+    return true
+}
+
+fun t23 () : Boolean {
+    val b = B<String>()
+    val v = b as B<String>   //ok
+    return true
+}
+
+fun t24 () : Boolean {
+    val b = B<String>()
+    val u = b as B<String>?  //TypeCastException
+    return true
+}
+
+fun t25 () : Boolean {
+    val c = C()
+    if(!c.isT("aaa")) return false
+    return true
+}
+
+fun t26 () : Boolean {
+    val d = D<String>()
+    if(!d.isT(B<String>())) return false
+    return true
+}
+
+fun box() : String {
+/*
+    if(!t1()) {
+        return "t1 failed"
+    }
+    if(!t2()) {
+        return "t2 failed"
+    }
+    if(!t3()) {
+        return "t3 failed"
+    }
+    if(!t4()) {
+         return "t4 failed"
+     }
+     if(!t5()) {
+         return "t5 failed"
+     }
+     if(!t6()) {
+         return "t6 failed"
+     }
+     if(!t7()) {
+         return "t7 failed"
+     }
+    if(!t8()) {
+        return "t8 failed"
+    }
+    if(!t9()) {
+        return "t9 failed"
+    }
+    if(!t10()) {
+        return "t10 failed"
+    }
+    if(!t11()) {
+         return "t11 failed"
+     }
+     if(!t12()) {
+         return "t12 failed"
+     }
+     if(!t13()) {
+         return "t13 failed"
+     }
+     if(!t14()) {
+         return "t14 failed"
+     }
+    if(!t15()) {
+        return "t15 failed"
+    }
+    if(!t16()) {
+        return "t16 failed"
+    }
+    if(!t17()) {
+        return "t17 failed"
+    }
+    if(!t18()) {
+         return "t18 failed"
+     }
+     if(!t19()) {
+         return "t19 failed"
+     }
+     if(!t20()) {
+         return "t10 failed"
+     }
+     if(!t21()) {
+         return "t21 failed"
+     }
+     if(!t22()) {
+         return "t22 failed"
+     }
+     if(!t23()) {
+         return "t23 failed"
+     }
+     if(!t24()) {
+         return "t24 failed"
+     }
+     if(!t25()) {
+         return "t25 failed"
+     }
+     */
+     if(!t26()) {
+         return "t26 failed"
+     }
+     return "OK"
+}
@@ -0,0 +1,4 @@
+// KT-297 Overload resolution ambiguity with required in trait
+trait ALE<T> : java.util.ArrayList<T> {
+   fun getOrValue(index: Int, value : T) : T = if(index >= 0 && index < size()) get(index) else value
+}
@@ -0,0 +1,17 @@
+class MyRange1() : Range<Int> {
+    override fun contains(item: Int) = true
+}
+
+class MyRange2() {
+    fun contains(item: Int) = true
+}
+
+fun box(): String {
+    if (1 in MyRange1()) {
+        if (1 in MyRange2()) {
+            return "OK"
+        }
+        return "fail 2"
+    }
+    return "fail 1"
+}
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`fun foo(b: Boolean): Int { return if (b) 15 else 20 }`
				`@@ -0,0 +1 @@`
				`fun f() { System.out?.println("Hello World"); }`