Merge remote branch 'origin/master'

Conflicts:
	compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java

idea/testData/cfg/ArrayAccess.instructions

@@ -36,15 +36,3 @@ l1:
 error:
     <ERROR>
 =====================
-== a ==
-val a = Array<Int>
----------------------
-l0:
-    <START>
-    r(Array)
-    r(Array<Int>)
-l1:
-    <END>
-error:
-    <ERROR>
-=====================

idea/testData/cfg/Assignments.instructions

@@ -55,56 +55,3 @@ l1:
 error:
     <ERROR>
 =====================
-== x ==
-var x = 1
----------------------
-l0:
-    <START>
-    r(1)
-l1:
-    <END>
-error:
-    <ERROR>
-=====================
-== y ==
-val y = true && false
----------------------
-l0:
-    <START>
-    r(true)
-    jf(l2)
-    r(false)
-l2:
-    r(true && false)
-l1:
-    <END>
-error:
-    <ERROR>
-=====================
-== z ==
-val z = false && true
----------------------
-l0:
-    <START>
-    r(false)
-    jf(l2)
-    r(true)
-l2:
-    r(false && true)
-l1:
-    <END>
-error:
-    <ERROR>
-=====================
-== t ==
-val t = Test()
----------------------
-l0:
-    <START>
-    r(Test)
-    r(Test())
-l1:
-    <END>
-error:
-    <ERROR>
-=====================

idea/testData/checker/UnreachableCode.jet

@@ -136,9 +136,9 @@ fun tf() : Int {
 }
 
 fun failtest(a : Int) : Int {
-  <error>if (fail() || true) {
+  if (fail() || <error>true</error>) {
 
-  }</error>
+  }
   <error>return 1</error>
 }
 

idea/testData/checkerWithErrorTypes/full/BreakContinue.jet

@@ -25,4 +25,61 @@ class C {
         <!NOT_A_LOOP_LABEL!>break@f<!>
     }
 
+    fun containsBreak(a: String?, b: String?) {
+        while (a == null) {
+            break;
+        }
+        a?.compareTo("2")
+    }
+
+    fun notContainsBreak(a: String?, b: String?) {
+        while (a == null) {
+            while (b == null) {
+                break;
+            }
+        }
+        a<!UNNECESSARY_SAFE_CALL!>?.<!>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<!UNNECESSARY_SAFE_CALL!>?.<!>compareTo("2")
+    }
+
+    fun containsBreakToOuterLoop(a: String?, b: String?) {
+        @loop while(b == null) {
+            while(a == null) {
+                break@loop
+            }
+            a<!UNNECESSARY_SAFE_CALL!>?.<!>compareTo("2")
+        }
+    }
+
+    fun containsBreakInsideLoopWithLabel(a: String?, array: Array<Int>) {
+        @ while(a == null) {
+            for (el in array) {
+                break@
+            }
+        }
+        a?.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?.compareTo("2")
+    }
 }

idea/testData/checkerWithErrorTypes/full/FunctionReturnTypes.jet

@@ -168,4 +168,42 @@ fun f(): Int = if (1 < 2) 1 else returnNothing()
 public fun <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>f<!>() = 1
 class B() {
    protected fun <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>f<!>() = "ss"
+}
+
+fun testFunctionLiterals() {
+    val endsWithVarDeclaration : fun() : Boolean = {
+        <!EXPECTED_TYPE_MISMATCH!>val x = 2<!>
+    }
+
+    val endsWithAssignment = { () : Int =>
+        val x = 1
+        <!EXPECTED_TYPE_MISMATCH!>x = 333<!>
+    }
+
+    val endsWithReAssignment = { () : Int =>
+        val x = 1
+        <!EXPECTED_TYPE_MISMATCH!>x += 333<!>
+    }
+
+    val endsWithFunDeclaration : fun() : String = {
+        val x = 1
+        x = 333
+        <!EXPECTED_TYPE_MISMATCH!>fun meow() : Unit {}<!>
+    }
+
+    val endsWithObjectDeclaration : fun() : Int = {
+        val x = 1
+        x = 333
+        <!EXPECTED_TYPE_MISMATCH!>object A {}<!>
+    }
+
+    val expectedUnitReturnType1 = { () : Unit =>
+        val x = 1
+    }
+
+    val expectedUnitReturnType2 = { () : Unit =>
+        fun meow() : Unit {}
+        object A {}
+    }
+
 }

idea/testData/checkerWithErrorTypes/full/Return.jet

@@ -0,0 +1,17 @@
+namespace return
+
+class A {
+    fun outer() {
+        fun inner() {
+            if (1 < 2)
+                return@inner
+            else
+                return@outer
+        }
+        if (1 < 2)
+            <!NOT_A_RETURN_LABEL!>return@A<!>
+        else if (2 < 3)
+            <!NOT_A_RETURN_LABEL!>return<!UNRESOLVED_REFERENCE!>@inner<!><!>
+        return@outer
+    }
+}

idea/testData/checkerWithErrorTypes/full/UnreachableCode.jet

@@ -136,16 +136,16 @@ fun tf() : Int {
 }
 
 fun failtest(a : Int) : Int {
-  <!UNREACHABLE_BECAUSE_OF_NOTHING!>if (fail() || true) {
+  if (fail() || <!UNREACHABLE_CODE!>true<!>) {
 
-  }<!>
-  <!UNREACHABLE_BECAUSE_OF_NOTHING!>return 1<!>
+  }
+  <!UNREACHABLE_CODE!>return 1<!>
 }
 
 fun foo(a : Nothing) : Unit {
   1
   a
-  <!UNREACHABLE_BECAUSE_OF_NOTHING!>2<!>
+  <!UNREACHABLE_CODE!>2<!>
 }
 
 fun fail() : Nothing {

idea/testData/codegen/regressions/kt343.jet

@@ -0,0 +1,24 @@
+import java.util.ArrayList
+
+fun launch(f : fun() : Unit) {
+    f()
+}
+
+fun box(): String {
+    val list = ArrayList<Int>()
+    val foo : fun() : Unit = {
+        list.add(2)  //first exception
+    }
+    foo()
+
+    launch({
+        list.add(3)
+    })
+
+    val bar = {
+        val x = 1   //second exception
+    }
+    bar()
+
+    return if (list.size() == 2 && list.get(0) == 2 && list.get(1) == 3) "OK" else "fail"
+}