Remove generated codegen tests, move all testData to box/

A single test file will be generated out of box/ directory

compiler/testData/codegen/box/defaultArguments/constructor/annotation.kt

@@ -0,0 +1,11 @@
+annotation class A(val a: Int = 0)
+
+A fun test1() = 1
+A(2) fun test2() = 1
+
+fun box(): String {
+   if ((test1() + test2()) == 2) {
+      return "OK"
+   }
+   return "fail"
+}

compiler/testData/codegen/box/defaultArguments/constructor/defArgs1.kt

@@ -0,0 +1,8 @@
+class A(val a: Int = 0)
+
+fun box(): String {
+   if (A().a == 0 && A(1).a == 1) {
+      return "OK"
+   }
+   return "fail"
+}

compiler/testData/codegen/box/defaultArguments/constructor/defArgs1InnerClass.kt

@@ -0,0 +1,14 @@
+class A {
+    inner class B(val a: String = "a", val b: Int = 55, val c: String = "c")
+}
+
+fun box(): String {
+    val bDefault = A().B()
+    val b = A().B("aa", 66, "cc")
+    if (bDefault.a == "a" && bDefault.b == 55 && bDefault.c == "c") {
+        if (b.a == "aa" && b.b == 66 && b.c == "cc") {
+            return "OK"
+        }
+    }
+    return "fail"
+}

compiler/testData/codegen/box/defaultArguments/constructor/defArgs2.kt

@@ -0,0 +1,13 @@
+class A(val a: Int = 0, val b: String = "a")
+
+fun box(): String {
+  val a1 = A()
+  val a2 = A(1)
+  val a3 = A(b = "b")
+  val a4 = A(2, "c")
+  if (a1.a != 0 && a1.b != "a") return "fail"
+  if (a2.a != 1 && a2.b != "a") return "fail"
+  if (a3.a != 0 && a3.b != "b") return "fail"
+  if (a4.a != 2 && a4.b != "c") return "fail"
+  return "OK"
+}

compiler/testData/codegen/box/defaultArguments/constructor/doubleDefArgs1InnerClass.kt

@@ -0,0 +1,14 @@
+class A {
+    inner class B(val a: Double = 1.0, val b: Int = 55, val c: String = "c")
+}
+
+fun box(): String {
+    val bDefault = A().B()
+    val b = A().B(2.0, 66, "cc")
+    if (bDefault.a == 1.0 && bDefault.b == 55 && bDefault.c == "c") {
+        if (b.a == 2.0 && b.b == 66 && b.c == "cc") {
+            return "OK"
+        }
+    }
+    return "fail"
+}

compiler/testData/codegen/box/defaultArguments/constructor/enum.kt

@@ -0,0 +1,11 @@
+enum class A(val a: Int = 1) {
+  FIRST: A()
+  SECOND: A(2)
+}
+
+fun box(): String {
+   if (A.FIRST.a == 1 && A.SECOND.a == 2) {
+      return "OK"
+   }
+   return "fail"
+}

compiler/testData/codegen/box/defaultArguments/constructor/enumWithOneDefArg.kt

@@ -0,0 +1,10 @@
+enum class Foo(val a: Int = 1, val b: String) {
+  B: Foo(2, "b")
+  C: Foo(b = "b")
+}
+
+fun box(): String {
+   if (Foo.B.a != 2 || Foo.B.b != "b") return "fail"
+   if (Foo.C.a != 1 || Foo.C.b != "b") return "fail"
+   return "OK"
+}

compiler/testData/codegen/box/defaultArguments/constructor/enumWithTwoDefArgs.kt

@@ -0,0 +1,14 @@
+enum class Foo(val a: Int = 1, val b: String = "a") {
+  A: Foo()
+  B: Foo(2, "b")
+  C: Foo(b = "b")
+  D: Foo(a = 2)
+}
+
+fun box(): String {
+   if (Foo.A.a != 1 || Foo.A.b != "a") return "fail"
+   if (Foo.B.a != 2 || Foo.B.b != "b") return "fail"
+   if (Foo.C.a != 1 || Foo.C.b != "b") return "fail"
+   if (Foo.D.a != 2 || Foo.D.b != "a") return "fail"
+   return "OK"
+}

compiler/testData/codegen/box/defaultArguments/constructor/enumWithTwoDoubleDefArgs.kt

@@ -0,0 +1,14 @@
+enum class Foo(val a: Double = 1.0, val b: Double = 1.0) {
+    A: Foo()
+    B: Foo(2.0, 2.0)
+    C: Foo(b = 2.0)
+    D: Foo(a = 2.0)
+}
+
+fun box(): String {
+    if (Foo.A.a != 1.0 || Foo.A.b != 1.0) return "fail"
+    if (Foo.B.a != 2.0 || Foo.B.b != 2.0) return "fail"
+    if (Foo.C.a != 1.0 || Foo.C.b != 2.0) return "fail"
+    if (Foo.D.a != 2.0 || Foo.D.b != 1.0) return "fail"
+    return "OK"
+}

compiler/testData/codegen/box/defaultArguments/constructor/kt2852.kt

@@ -0,0 +1,7 @@
+fun box(): String {
+    val o = object {
+        inner class A(val value: String = "OK")
+    }
+
+    return o.A().value
+}

compiler/testData/codegen/box/defaultArguments/function/extentionFunction.kt

@@ -0,0 +1,9 @@
+fun Int.foo(a: Int = 1): Int {
+    return a
+}
+
+fun box(): String  {
+    if (1.foo() != 1) return "fail"
+    if (1.foo(2) != 2) return "fail"
+    return "OK"
+}

compiler/testData/codegen/box/defaultArguments/function/extentionFunctionDouble.kt

@@ -0,0 +1,9 @@
+fun Double.foo(a: Double = 1.0): Double {
+    return a
+}
+
+fun box(): String  {
+    if (1.0.foo() != 1.0) return "fail"
+    if (1.0.foo(2.0) != 2.0) return "fail"
+    return "OK"
+}

compiler/testData/codegen/box/defaultArguments/function/extentionFunctionDoubleTwoArgs.kt

@@ -0,0 +1,11 @@
+fun Double.foo(a: Double = 1.0, b: Double = 1.0): Double {
+    return a + b
+}
+
+fun box(): String  {
+    if (1.0.foo() != 2.0) return "fail"
+    if (1.0.foo(2.0, 2.0) != 4.0) return "fail"
+    if (1.0.foo(a = 2.0) != 3.0) return "fail"
+    if (1.0.foo(b = 2.0) != 3.0) return "fail"
+    return "OK"
+}

compiler/testData/codegen/box/defaultArguments/function/extentionFunctionInClassObject.kt

@@ -0,0 +1,17 @@
+class A {
+  class object {
+    fun Int.foo(a: Int = 1): Int {
+        return a
+    }
+
+    fun test(): String {
+        if (1.foo() != 1) return "fail"
+        if (1.foo(2) != 2) return "fail"
+        return "OK"
+    }
+  }
+}
+
+fun box(): String  {
+   return A.test()
+}

compiler/testData/codegen/box/defaultArguments/function/extentionFunctionInObject.kt

@@ -0,0 +1,15 @@
+object A {
+  fun Int.foo(a: Int = 1): Int {
+      return a
+  }
+
+  fun test(): String {
+      if (1.foo() != 1) return "fail"
+      if (1.foo(2) != 2) return "fail"
+      return "OK"
+  }
+}
+
+fun box(): String  {
+   return A.test()
+}

compiler/testData/codegen/box/defaultArguments/function/extentionFunctionWithOneDefArg.kt

@@ -0,0 +1,9 @@
+fun Int.foo(a: Int = 1, b: String): Int {
+    return a
+}
+
+fun box(): String  {
+    if (1.foo(b = "b") != 1) return "fail"
+    if (1.foo(2, "b") != 2) return "fail"
+    return "OK"
+}

compiler/testData/codegen/box/defaultArguments/function/funInTrait.kt

@@ -0,0 +1,14 @@
+trait Foo {
+    fun foo(a: Double = 1.0): Double
+}
+
+class FooImpl : Foo {
+    override fun foo(a: Double): Double {
+        return a
+    }
+}
+fun box(): String  {
+    if (FooImpl().foo() != 1.0) return "fail"
+    if (FooImpl().foo(2.0) != 2.0) return "fail"
+    return "OK"
+}

compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunction.kt

@@ -0,0 +1,15 @@
+class A {
+  fun Int.foo(a: Int = 1): Int {
+      return a
+  }
+
+  fun test(): String {
+      if (1.foo() != 1) return "fail"
+      if (1.foo(2) != 2) return "fail"
+      return "OK"
+  }
+}
+
+fun box(): String  {
+   return A().test()
+}

compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunctionDouble.kt

@@ -0,0 +1,15 @@
+class A {
+  fun Double.foo(a: Double = 1.0): Double {
+      return a
+  }
+
+  fun test(): String {
+      if (1.0.foo() != 1.0) return "fail"
+      if (1.0.foo(2.0) != 2.0) return "fail"
+      return "OK"
+  }
+}
+
+fun box(): String  {
+   return A().test()
+}

compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunctionDoubleTwoArgs.kt

@@ -0,0 +1,17 @@
+class A {
+    fun Double.foo(a: Double = 1.0, b: Double = 1.0): Double {
+        return a + b
+    }
+
+    fun test(): String {
+        if (1.0.foo() != 2.0) return "fail"
+        if (1.0.foo(2.0, 2.0) != 4.0) return "fail"
+        if (1.0.foo(a = 2.0) != 3.0) return "fail"
+        if (1.0.foo(b = 2.0) != 3.0) return "fail"
+        return "OK"
+    }
+}
+
+fun box(): String  {
+    return A().test()
+}

compiler/testData/codegen/box/extensionProperties/inClass.kt

@@ -0,0 +1,11 @@
+class Test {
+  val Int.foo: String = "OK"
+
+  fun test(): String {
+    return 1.foo
+  }
+}
+
+fun box(): String {
+   return Test().test()
+}

compiler/testData/codegen/box/extensionProperties/inClassLongTypeInReceiver.kt

@@ -0,0 +1,16 @@
+class Test {
+  var Double.fooDouble: String = "fail"
+  var Long.fooLong: String = "fail"
+
+  fun test(): String {
+     val d = 1.0
+     d.fooDouble = "O"
+     val l = 1.toLong()
+     l.fooLong = "K"
+     return d.fooDouble + l.fooLong
+  }
+}
+
+fun box(): String {
+   return Test().test()
+}

compiler/testData/codegen/box/extensionProperties/inClassWithEmptySetter.kt

@@ -0,0 +1,13 @@
+class Test {
+  var Int.foo: String = "fail"
+
+  fun test(): String {
+    val i = 1
+    i.foo = "OK"
+    return i.foo
+  }
+}
+
+fun box(): String {
+   return Test().test()
+}

compiler/testData/codegen/box/extensionProperties/inClassWithGetter.kt

@@ -0,0 +1,15 @@
+class Test {
+  val Int.foo: String = "OK"
+    get() {
+        val a = $foo
+        return "OK"
+    }
+
+  fun test(): String {
+     return 1.foo
+  }
+}
+
+fun box(): String {
+   return Test().test()
+}

compiler/testData/codegen/box/extensionProperties/inClassWithPrivateGetter.kt

@@ -0,0 +1,15 @@
+class Test {
+  private val Int.foo: String = "OK"
+    get() {
+        val a = $foo
+        return "OK"
+    }
+
+  fun test(): String {
+     return 1.foo
+  }
+}
+
+fun box(): String {
+   return Test().test()
+}

compiler/testData/codegen/box/extensionProperties/inClassWithPrivateSetter.kt

@@ -0,0 +1,16 @@
+class Test {
+  var Int.foo: String = "OK"
+    private set(str: String) {
+        $foo = str
+    }
+
+  fun test(): String {
+     val i = 1
+     i.foo = "OK"
+     return i.foo
+  }
+}
+
+fun box(): String {
+   return Test().test()
+}

compiler/testData/codegen/box/extensionProperties/inClassWithSetter.kt

@@ -0,0 +1,16 @@
+class Test {
+  var Int.foo: String = "fail"
+    set(str: String) {
+        $foo = str
+    }
+
+  fun test(): String {
+      val i = 1
+      i.foo = "OK"
+      return i.foo
+  }
+}
+
+fun box(): String {
+   return Test().test()
+}

compiler/testData/codegen/box/extensionProperties/topLevel.kt

@@ -0,0 +1,5 @@
+val Int.foo: String = "OK"
+
+fun box(): String {
+   return 1.foo
+}

compiler/testData/codegen/box/extensionProperties/topLevelLongTypeInReceiver.kt

@@ -0,0 +1,10 @@
+var Double.fooDouble: String = "fail"
+var Long.fooLong: String = "fail"
+
+fun box(): String {
+   val d = 1.0
+   d.fooDouble = "O"
+   val l = 1.toLong()
+   l.fooLong = "K"
+   return d.fooDouble + l.fooLong
+}

compiler/testData/codegen/box/extensionProperties/topLevelSetterLongTypeInReceiver.kt

@@ -0,0 +1,17 @@
+var Double.fooDouble: String = "fail"
+  set(str: String) {
+      $fooDouble = str
+  }
+
+var Long.fooLong: String = "fail"
+  set(str: String) {
+      $fooLong = str
+  }
+
+fun box(): String {
+   val d = 1.0
+   d.fooDouble = "O"
+   val l = 1.toLong()
+   l.fooLong = "K"
+   return d.fooDouble + l.fooLong
+}

compiler/testData/codegen/box/extensionProperties/topLevelWithGetter.kt

@@ -0,0 +1,8 @@
+val Int.foo: String = "OK"
+  get() {
+    return $foo
+  }
+
+fun box(): String {
+   return 1.foo
+}

compiler/testData/codegen/box/extensionProperties/topLevelWithSetter.kt

@@ -0,0 +1,10 @@
+var Int.foo: String = "fail"
+  set(str: String) {
+      $foo = str
+  }
+
+fun box(): String {
+  val i = 1
+  i.foo = "OK"
+  return i.foo
+}

compiler/testData/codegen/box/innerNested/createNestedClass.kt

@@ -0,0 +1,13 @@
+class A {
+    class B1
+    class B2(val x: Int)
+    class B3(val x: Long, val y: Int)
+    class B4(val str: String)
+}
+
+
+fun box(): String {
+    A.B1()
+    val b2 = A.B2(A.B3(42, 42).y)
+    return A.B4("OK").str
+}

compiler/testData/codegen/box/innerNested/createdNestedInOuterMember.kt

@@ -0,0 +1,14 @@
+fun foo(f: (Int) -> Int) = f(0)
+
+class Outer {
+    class Nested {
+        val y = foo { a -> a }
+    }
+
+    fun bar(): String {
+        val a = Nested()
+        return "OK"
+    }
+}
+
+fun box() = Outer().bar()

compiler/testData/codegen/box/innerNested/dataLocalVariable.kt

@@ -0,0 +1,6 @@
+fun ok(b: Boolean) = if (b) "OK" else "Fail"
+
+fun box(): String {
+    val data = java.util.Arrays.asList("foo", "bar")!!
+    return ok(data.contains("foo"))
+}

compiler/testData/codegen/box/innerNested/extensionFun.kt

@@ -0,0 +1,31 @@
+class Outer {
+    class Nested
+    inner class Inner
+    
+    fun Inner.foo() {
+        Outer()
+        Nested()
+        Inner()
+    }
+    
+    fun Nested.bar() {
+        Outer()
+        Nested()
+        Inner()
+    }
+    
+    fun Outer.baz() {
+        Outer()
+        Nested()
+        Inner()
+    }
+    
+    fun box(): String {
+        Inner().foo()
+        Nested().bar()
+        baz()
+        return "OK"
+    }
+}
+
+fun box() = Outer().box()

compiler/testData/codegen/box/innerNested/importNestedClass.kt

@@ -0,0 +1,18 @@
+import A.B
+import A.B.C
+
+class A {
+    class B {
+        class C
+    }
+}
+
+fun box(): String {
+    val a = A()
+    val b = B()
+    val ab = A.B()
+    val c = C()
+    val bc = B.C()
+    val abc = A.B.C()
+    return "OK"
+}

compiler/testData/codegen/box/innerNested/innerGeneric.kt

@@ -0,0 +1,11 @@
+class Outer {
+    inner class Inner<T>(val t: T) {
+        fun box() = t
+    }
+}
+
+fun box(): String {
+    if (Outer().Inner("OK").box() != "OK") return "Fail"
+    val x: Outer.Inner<String> = Outer().Inner("OK")
+    return x.box()
+}

compiler/testData/codegen/box/innerNested/innerLabeledThis.kt

@@ -0,0 +1,11 @@
+class Outer {
+    inner class Inner {
+        fun O() = this@Outer.O
+        val K = this@Outer.K()
+    }
+    
+    val O = "O"
+    fun K() = "K"
+}
+
+fun box() = Outer().Inner().O() + Outer().Inner().K

compiler/testData/codegen/box/innerNested/innerSimple.kt

@@ -0,0 +1,7 @@
+class Outer {
+    inner class Inner {
+        fun box() = "OK"
+    }
+}
+
+fun box() = Outer().Inner().box()

compiler/testData/codegen/box/innerNested/nestedClassObject.kt

@@ -0,0 +1,12 @@
+class Outer {
+    class Nested {
+        class object {
+            val O = "O"
+            val K = "K"
+        }
+    }
+    
+    fun O() = Nested.O
+}
+
+fun box() = Outer().O() + Outer.Nested.K

compiler/testData/codegen/box/innerNested/nestedEnumConstant.kt

@@ -0,0 +1,8 @@
+class Outer {
+    enum class Nested {
+        O
+        K
+    }
+}
+
+fun box() = "${Outer.Nested.O}${Outer.Nested.K}"

compiler/testData/codegen/box/innerNested/nestedGeneric.kt

@@ -0,0 +1,12 @@
+class Outer {
+    class Nested<T>(val t: T) {
+        fun box() = t
+    }
+}
+
+fun box(): String {
+    if (Outer.Nested<String>("OK").box() != "OK") return "Fail"
+    
+    val x: Outer.Nested<String> = Outer.Nested("OK")
+    return x.box()
+}

compiler/testData/codegen/box/innerNested/nestedInPackage.kt

@@ -0,0 +1,10 @@
+package Package
+
+class Outer {
+    class Nested {
+        val O = "O"
+        val K = "K"
+    }
+}
+
+fun box() = Package.Outer.Nested().O + Outer.Nested().K

compiler/testData/codegen/box/innerNested/nestedObjects.kt

@@ -0,0 +1,9 @@
+object A {
+    object B {
+        object C {
+            val ok = "OK"
+        }
+    }
+}
+
+fun box() = A.B.C.ok

compiler/testData/codegen/box/innerNested/nestedSimple.kt

@@ -0,0 +1,7 @@
+class Outer {
+    class Nested {
+        fun box() = "OK"
+    }
+}
+
+fun box() = Outer.Nested().box()

compiler/testData/codegen/box/instructions/swap/swapRefToSharedVarInt.kt

@@ -0,0 +1,11 @@
+fun box(): String {
+    var a: Int
+    a = 12
+    fun f() {
+        foo(a)
+    }
+
+    return "OK"
+}
+
+fun foo(l: Int) {}

compiler/testData/codegen/box/instructions/swap/swapRefToSharedVarLong.kt

@@ -0,0 +1,13 @@
+//KT-3042 Attempt to split long or double on the stack excepion
+
+fun box(): String {
+    var a: Long
+    a = 12.toLong()
+    fun f() {
+        foo(a)
+    }
+
+    return "OK"
+}
+
+fun foo(l: Long) {}

compiler/testData/codegen/box/intrinsics/compareTo.kt

@@ -0,0 +1,16 @@
+fun box(): String {
+    val sb = StringBuilder()
+    
+    for (i in -1..1) {
+        for (j in -1..1) {
+            val a = i compareTo j
+            val b = i.compareTo(j)
+            if (a != b) {
+                sb.append("$i compareTo $j:  $a != $b\n")
+            }
+        }
+    }
+    
+    if (sb.length() == 0) return "OK"
+    return "Fail:\n$sb"
+}

compiler/testData/codegen/box/intrinsics/ea35953.kt

@@ -0,0 +1,6 @@
+fun box(): String {
+    if (12.toString() equals "13") {
+        return "Fail"
+    }
+    return "OK"
+}

compiler/testData/codegen/box/intrinsics/longRangeWithExplicitDot.kt

@@ -0,0 +1,6 @@
+fun box(): String {
+  val l: Long = 1
+  val l2: Long = 2
+  val r = l.rangeTo(l2)
+  return if (r.start == l && r.end == l2) "OK" else "fail"
+}

compiler/testData/codegen/box/intrinsics/tostring.kt

@@ -0,0 +1,25 @@
+fun box(): String {
+    if (239.toByte().toString() != (239.toByte() as Byte?).toString()) return "byte failed"
+    if (239.toShort().toString() != (239.toShort() as Short?).toString()) return "short failed"
+    if (239.toInt().toString() != (239.toInt() as Int?).toString()) return "int failed"
+    if (239.toFloat().toString() != (239.toFloat() as Float?).toString()) return "float failed"
+    if (239.toLong().toString() != (239.toLong() as Long?).toString()) return "long failed"
+    if (239.toDouble().toString() != (239.toDouble() as Double?).toString()) return "double failed"
+    if (true.toString() != (true as Boolean?).toString()) return "boolean failed"
+    if ('a'.toChar().toString() != ('a'.toChar() as Char?).toString()) return "char failed"
+
+    if ("${239.toByte()}" != (239.toByte() as Byte?).toString()) return "byte template failed"
+    if ("${239.toShort()}" != (239.toShort() as Short?).toString()) return "short  template failed"
+    if ("${239.toInt()}" != (239.toInt() as Int?).toString()) return "int  template failed"
+    if ("${239.toFloat()}" != (239.toFloat() as Float?).toString()) return "float  template failed"
+    if ("${239.toLong()}" != (239.toLong() as Long?).toString()) return "long  template failed"
+    if ("${239.toDouble()}" != (239.toDouble() as Double?).toString()) return "double  template failed"
+    if ("${true}" != (true as Boolean?).toString()) return "boolean  template failed"
+    if ("${'a'.toChar()}" != ('a'.toChar() as Char?).toString()) return "char  template failed"
+
+    for(b in 0..255) {
+       if("${b.toByte()}" != (b.toByte() as Byte?).toString()) return "byte conversion failed"
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/labels/propertyAccessor.kt

@@ -0,0 +1,29 @@
+val Int.getter: Int
+    get() {
+        return this@getter
+    }
+
+var Int.setter1: Int = 2
+    get() {
+        return this@setter1
+    }
+    set(i: Int) {
+        $setter1 = this@setter1
+    }
+
+var Int.setter2: Int = 2
+    set(i: Int) {
+        $setter2 = this@setter2
+    }
+
+fun box(): String {
+    val i = 1
+    if (i.getter != 1) return "getter failed"
+
+    i.setter1 = 2
+    if (i.setter1 != 1) return "setter1 failed"
+    i.setter2 = 2
+    if (i.setter2 != 1) return "setter2 failed"
+
+    return "OK"
+}

compiler/testData/codegen/box/labels/propertyAccessorFunctionLiteral.kt

@@ -0,0 +1,23 @@
+val Int.getter: Int
+    get() {
+        return {
+            this@getter
+        }.invoke()
+    }
+
+var Int.setter: Int = 1
+    set(i: Int) {
+        $setter = {
+            this@setter
+        }.invoke()
+    }
+
+fun box(): String {
+    val i = 1
+    if (i.getter != 1) return "getter failed"
+
+    i.setter = 2
+    if (i.setter != 1) return "setter failed"
+
+    return "OK"
+}

compiler/testData/codegen/box/labels/propertyAccessorInnerExtensionFun.kt

@@ -0,0 +1,27 @@
+val Int.getter: Int
+    get() {
+        val extFun = { Int.() ->
+            this@getter
+        }
+        return this@getter.extFun()
+    }
+
+
+var Int.setter: Int = 1
+    set(i: Int) {
+        val extFun = { Int.() ->
+            this@setter
+        }
+        this@setter.extFun()
+    }
+
+
+fun box(): String {
+    val i = 1
+    if (i.getter != 1) return "getter failed"
+
+    i.setter = 1
+    if (i.setter != 1) return "setter failed"
+
+    return "OK"
+}

compiler/testData/codegen/box/labels/propertyAccessorObject.kt

@@ -0,0 +1,53 @@
+trait Base {
+    fun foo(): Int
+}
+
+val Int.getter: Int
+    get() {
+        return object: Base {
+            override fun foo(): Int {
+                return this@getter
+            }
+        }.foo()
+    }
+
+var Int.setter1: Int = 2
+    set(i: Int) {
+        $setter1 = object: Base {
+            override fun foo(): Int {
+                this@setter1
+                return 1
+            }
+        }.foo()
+    }
+
+
+var Int.setter2: Int = 2
+    get() {
+        return object: Base {
+            override fun foo(): Int {
+                return this@setter2
+            }
+        }.foo()
+    }
+    set(i: Int) {
+        $setter2 = object: Base {
+            override fun foo(): Int {
+                this@setter2
+                return 1
+            }
+        }.foo()
+    }
+
+
+fun box(): String {
+    val i = 1
+    if (i.getter != 1) return "getter failed"
+
+    i.setter1 = 2
+    if (i.setter1 != 1) return "setter1 failed"
+    i.setter2 = 2
+    if (i.setter2 != 1) return "setter2 failed"
+
+    return "OK"
+}

compiler/testData/codegen/box/labels/propertyInClassAccessor.kt

@@ -0,0 +1,17 @@
+class Test {
+    val Int.innerGetter: Int
+        get() {
+            return this@innerGetter
+        }
+
+    fun test(): Int {
+        val i = 1
+        if (i.innerGetter != 1) return 0
+        return 1
+    }
+}
+
+fun box(): String {
+    if (Test().test() != 1) return "inner getter or setter failed"
+    return "OK"
+}

compiler/testData/codegen/box/multiDecl/ComplexInitializer.kt

@@ -0,0 +1,13 @@
+class A {
+    fun component1() = 1
+    fun component2() = 2
+
+}
+
+fun A.getA() = this
+
+fun box() : String {
+    val (a, b) = A().getA().getA()
+
+    return if (a == 1 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/SimpleVals.kt

@@ -0,0 +1,9 @@
+class A {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+fun box() : String {
+    val (a, b) = A()
+    return if (a == 1 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/SimpleValsExtensions.kt

@@ -0,0 +1,10 @@
+class A {
+}
+
+fun A.component1() = 1
+fun A.component2() = 2
+
+fun box() : String {
+    val (a, b) = A()
+    return if (a == 1 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/SimpleVarsExtensions.kt

@@ -0,0 +1,10 @@
+class A {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+fun box() : String {
+    var (a, b) = A()
+    a = b
+    return if (a == 2 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/ValCapturedInFunctionLiteral.kt

@@ -0,0 +1,13 @@
+class A {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+fun box() : String {
+    val (a, b) = A()
+
+    val run = {
+        a
+    }
+    return if (run() == 1 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/ValCapturedInLocalFunction.kt

@@ -0,0 +1,13 @@
+class A {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+fun box() : String {
+    val (a, b) = A()
+
+    fun run(): Int {
+        return a
+    }
+    return if (run() == 1 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/ValCapturedInObjectLiteral.kt

@@ -0,0 +1,16 @@
+class A {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+
+fun box() : String {
+    val (a, b) = A()
+
+    val local = object {
+        public fun run() : Int {
+            return a
+        }
+    }
+    return if (local.run() == 1 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/VarCapturedInFunctionLiteral.kt

@@ -0,0 +1,15 @@
+class A {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+
+fun box() : String {
+    var (a, b) = A()
+
+    val local = {
+        a = 3
+    }
+    local()
+    return if (a == 3 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/VarCapturedInLocalFunction.kt

@@ -0,0 +1,15 @@
+class A {
+}
+
+fun A.component1() = 1
+fun A.component2() = 2
+
+fun box() : String {
+    var (a, b) = A()
+
+    fun local() {
+        a = 3
+    }
+    local()
+    return if (a == 3 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/VarCapturedInObjectLiteral.kt

@@ -0,0 +1,17 @@
+class A {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+
+fun box() : String {
+    var (a, b) = A()
+
+    val local = object {
+        public fun run() {
+            a = 3
+        }
+    }
+    local.run()
+    return if (a == 3 && b == 2) "OK" else "fail"
+}

compiler/testData/codegen/box/multiDecl/component.kt

@@ -0,0 +1,17 @@
+class S(val a: String, val b: String) {
+  fun component1() : String = a
+  fun component2() : String = b
+}
+
+fun S.component3() = ((a + b) as java.lang.String).substring(2)
+
+class Tester() {
+  fun box() : String {
+    val (o,k,ok,ok2) = S("O","K")
+    return o + k + ok + ok2
+  }
+
+  fun S.component4() = ((a + b) as java.lang.String).substring(2)
+}
+
+fun box() = Tester().box()

compiler/testData/codegen/box/multiDecl/forArray/MultiDeclFor.kt

@@ -0,0 +1,18 @@
+class C(val i: Int) {
+  fun component1() = i + 1
+  fun component2() = i + 2
+}
+
+fun doTest(l : Array<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/MultiDeclForComponentExtensions.kt

@@ -0,0 +1,19 @@
+class C(val i: Int) {
+}
+
+fun C.component1() = i + 1
+fun C.component2() = i + 2
+
+fun doTest(l : Array<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/MultiDeclForComponentMemberExtensions.kt

@@ -0,0 +1,21 @@
+class C(val i: Int) {
+}
+
+class M {
+  fun C.component1() = i + 1
+  fun C.component2() = i + 2
+
+  fun doTest(l : Array<C>): String {
+      var s = ""
+      for ((a, b) in l) {
+        s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -0,0 +1,21 @@
+class C(val i: Int) {
+}
+
+class M {
+  fun C.component1() = i + 1
+  fun C.component2() = i + 2
+}
+
+fun M.doTest(l : Array<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/MultiDeclForValCaptured.kt

@@ -0,0 +1,18 @@
+class C(val i: Int) {
+  fun component1() = i + 1
+  fun component2() = i + 2
+}
+
+fun doTest(l : Array<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<C>(3, {x -> C(x)})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/int/MultiDeclForComponentExtensions.kt

@@ -0,0 +1,16 @@
+fun Int.component1() = this + 1
+fun Int.component2() = this + 2
+
+fun doTest(l : Array<Int>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Int>(3, {x -> x})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/int/MultiDeclForComponentExtensionsValCaptured.kt

@@ -0,0 +1,16 @@
+fun Int.component1() = this + 1
+fun Int.component2() = this + 2
+
+fun doTest(l : Array<Int>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Int>(3, {x -> x})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/int/MultiDeclForComponentMemberExtensions.kt

@@ -0,0 +1,18 @@
+class M {
+  fun Int.component1() = this + 1
+  fun Int.component2() = this + 2
+
+  fun doTest(l : Array<Int>): String {
+      var s = ""
+      for ((a, b) in l) {
+        s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+fun box(): String {
+  val l = Array<Int>(3, {x -> x})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -0,0 +1,18 @@
+class M {
+  fun Int.component1() = this + 1
+  fun Int.component2() = this + 2
+}
+
+fun M.doTest(l : Array<Int>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Int>(3, {x -> x})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/long/MultiDeclForComponentExtensions.kt

@@ -0,0 +1,16 @@
+fun Long.component1() = this + 1
+fun Long.component2() = this + 2
+
+fun doTest(l : Array<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Long>(3, {x -> x.toLong()})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/long/MultiDeclForComponentExtensionsValCaptured.kt

@@ -0,0 +1,16 @@
+fun Long.component1() = this + 1
+fun Long.component2() = this + 2
+
+fun doTest(l : Array<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Long>(3, {x -> x.toLong()})
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/long/MultiDeclForComponentMemberExtensions.kt

@@ -0,0 +1,18 @@
+class M {
+  fun Long.component1() = this + 1
+  fun Long.component2() = this + 2
+
+  fun doTest(l : Array<Long>): String {
+      var s = ""
+      for ((a, b) in l) {
+        s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+fun box(): String {
+  val l = Array<Long>(3, {x -> x.toLong()})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forArray/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -0,0 +1,18 @@
+class M {
+  fun Long.component1() = this + 1
+  fun Long.component2() = this + 2
+}
+
+fun M.doTest(l : Array<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = Array<Long>(3, {x -> x.toLong()})
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclFor.kt

@@ -0,0 +1,21 @@
+class C(val i: Int) {
+  fun component1() = i + 1
+  fun component2() = i + 2
+}
+
+fun doTest(l : java.util.ArrayList<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<C>()
+  l.add(C(0))
+  l.add(C(1))
+  l.add(C(2))
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentExtensions.kt

@@ -0,0 +1,22 @@
+class C(val i: Int) {
+}
+
+fun C.component1() = i + 1
+fun C.component2() = i + 2
+
+fun doTest(l : java.util.ArrayList<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<C>()
+  l.add(C(0))
+  l.add(C(1))
+  l.add(C(2))
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentMemberExtensions.kt

@@ -0,0 +1,24 @@
+class C(val i: Int) {
+}
+
+class M {
+  fun C.component1() = i + 1
+  fun C.component2() = i + 2
+
+  fun doTest(l : java.util.ArrayList<C>): String {
+      var s = ""
+      for ((a, b) in l) {
+        s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<C>()
+  l.add(C(0))
+  l.add(C(1))
+  l.add(C(2))
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -0,0 +1,24 @@
+class C(val i: Int) {
+}
+
+class M {
+  fun C.component1() = i + 1
+  fun C.component2() = i + 2
+}
+
+fun M.doTest(l : java.util.ArrayList<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<C>()
+  l.add(C(0))
+  l.add(C(1))
+  l.add(C(2))
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForValCaptured.kt

@@ -0,0 +1,21 @@
+class C(val i: Int) {
+  fun component1() = i + 1
+  fun component2() = i + 2
+}
+
+fun doTest(l : java.util.ArrayList<C>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<C>()
+  l.add(C(0))
+  l.add(C(1))
+  l.add(C(2))
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentExtensions.kt

@@ -0,0 +1,19 @@
+fun Long.component1() = this + 1
+fun Long.component2() = this + 2
+
+fun doTest(l : java.util.ArrayList<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<Long>()
+  l.add(0)
+  l.add(1)
+  l.add(2)
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentExtensionsValCaptured.kt

@@ -0,0 +1,19 @@
+fun Long.component1() = this + 1
+fun Long.component2() = this + 2
+
+fun doTest(l : java.util.ArrayList<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<Long>()
+  l.add(0)
+  l.add(1)
+  l.add(2)
+  val s = doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentMemberExtensions.kt

@@ -0,0 +1,21 @@
+class M {
+  fun Long.component1() = this + 1
+  fun Long.component2() = this + 2
+
+  fun doTest(l : java.util.ArrayList<Long>): String {
+      var s = ""
+      for ((a, b) in l) {
+        s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<Long>()
+  l.add(0)
+  l.add(1)
+  l.add(2)
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -0,0 +1,21 @@
+class M {
+  fun Long.component1() = this + 1
+  fun Long.component2() = this + 2
+}
+
+fun M.doTest(l : java.util.ArrayList<Long>): String {
+    var s = ""
+    for ((a, b) in l) {
+      s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+  val l = java.util.ArrayList<Long>()
+  l.add(0)
+  l.add(1)
+  l.add(2)
+  val s = M().doTest(l)
+  return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/MultiDeclFor.kt

@@ -0,0 +1,34 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun component1() = i + 1
+    fun component2() = i + 2
+    fun rangeTo(c: C) = Range(this, c)
+}
+
+fun doTest(): String {
+    var s = ""
+    for ((a, b) in C(0)..C(2)) {
+        s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+    val s = doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentExtensions.kt

@@ -0,0 +1,34 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun rangeTo(c: C) = Range(this, c)
+}
+fun C.component1() = i + 1
+fun C.component2() = i + 2
+
+fun doTest(): String {
+    var s = ""
+    for ((a, b) in C(0)..C(2)) {
+        s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+    val s = doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentMemberExtensions.kt

@@ -0,0 +1,38 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun rangeTo(c: C) = Range(this, c)
+}
+
+class M {
+  fun C.component1() = i + 1
+  fun C.component2() = i + 2
+
+  fun doTest(): String {
+      var s = ""
+      for ((a, b) in C(0)..C(2)) {
+          s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+
+fun box(): String {
+    val s = M().doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -0,0 +1,37 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun rangeTo(c: C) = Range(this, c)
+}
+
+class M {
+  fun C.component1() = i + 1
+  fun C.component2() = i + 2
+}
+
+fun M.doTest(): String {
+    var s = ""
+    for ((a, b) in C(0)..C(2)) {
+        s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+    val s = M().doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForValCaptured.kt

@@ -0,0 +1,34 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun component1() = i + 1
+    fun component2() = i + 2
+    fun rangeTo(c: C) = Range(this, c)
+}
+
+fun doTest(): String {
+    var s = ""
+    for ((a, b) in C(0)..C(2)) {
+        s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+    val s = doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclFor.kt

@@ -0,0 +1,34 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun component1() = i + 1
+    fun component2() = i + 2
+    fun rangeTo(c: C) = Range(this, c)
+}
+
+fun doTest(): String {
+    var s = ""
+    for ((a, b) in C(0) rangeTo C(2)) {
+        s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+    val s = doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentExtensions.kt

@@ -0,0 +1,34 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun rangeTo(c: C) = Range(this, c)
+}
+fun C.component1() = i + 1
+fun C.component2() = i + 2
+
+fun doTest(): String {
+    var s = ""
+    for ((a, b) in C(0) rangeTo C(2)) {
+        s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+    val s = doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentMemberExtensions.kt

@@ -0,0 +1,38 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun rangeTo(c: C) = Range(this, c)
+}
+
+class M {
+  fun C.component1() = i + 1
+  fun C.component2() = i + 2
+
+  fun doTest(): String {
+      var s = ""
+      for ((a, b) in C(0) rangeTo C(2)) {
+          s += "$a:$b;"
+      }
+      return s
+  }
+}
+
+
+fun box(): String {
+    val s = M().doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt

@@ -0,0 +1,37 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun rangeTo(c: C) = Range(this, c)
+}
+
+class M {
+  fun C.component1() = i + 1
+  fun C.component2() = i + 2
+}
+
+fun M.doTest(): String {
+    var s = ""
+    for ((a, b) in C(0) rangeTo C(2)) {
+        s += "$a:$b;"
+    }
+    return s
+}
+
+fun box(): String {
+    val s = M().doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}

compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForValCaptured.kt

@@ -0,0 +1,34 @@
+class Range(val from : C, val to: C) {
+    fun iterator() = It(from, to)
+}
+
+class It(val from: C, val to: C) {
+    var c = from.i
+
+    fun next(): C {
+        val next = C(c)
+        c++
+        return next
+    }
+
+    fun hasNext(): Boolean = c <= to.i
+}
+
+class C(val i : Int) {
+    fun component1() = i + 1
+    fun component2() = i + 2
+    fun rangeTo(c: C) = Range(this, c)
+}
+
+fun doTest(): String {
+    var s = ""
+    for ((a, b) in C(0) rangeTo C(2)) {
+        s += {"$a:$b;"}()
+    }
+    return s
+}
+
+fun box(): String {
+    val s = doTest()
+    return if (s == "1:2;2:3;3:4;") "OK" else "fail: $s"
+}