Move regression tests from stdlib to compiler

#KT-5770 FIxed

compiler/testData/codegen/boxWithStdlib/regressions/Kt1149.kt

@@ -0,0 +1,20 @@
+package test.regressions.kt1149
+
+import java.util.ArrayList
+import kotlin.util.*
+
+public trait SomeTrait {
+    fun foo()
+}
+
+fun box(): String {
+    val list = ArrayList<SomeTrait>()
+    var res = ArrayList<String>()
+    list.add(object : SomeTrait {
+        override fun foo() {
+            res.add("anonymous.foo()")
+        }
+    })
+    list.forEach{ it.foo() }
+    return if ("anonymous.foo()" == res[0]) "OK" else "fail"
+}

compiler/testData/codegen/boxWithStdlib/regressions/Kt1619Test.kt

@@ -0,0 +1,18 @@
+package regressions
+
+class Kt1619Test {
+
+    fun doSomething(list: List<String?>): Int {
+        return list.size()
+    }
+
+    fun testCollectionNotNullCanBeUsedForNullables(): Int {
+        val list: List<String> = arrayListOf("foo", "bar")
+        return doSomething(list)
+    }
+}
+
+fun box(): String {
+   return if (Kt1619Test().testCollectionNotNullCanBeUsedForNullables() == 2) "OK" else "fail"
+}
+

compiler/testData/codegen/boxWithStdlib/regressions/Kt2495Test.kt

@@ -0,0 +1,15 @@
+package regressions
+
+fun f(xs: Iterator<Int>): Int {
+    var answer = 0
+    for (x in xs)  {
+        answer += x
+    }
+    return answer
+}
+
+fun box(): String {
+    val list = arrayList(1, 2, 3)
+    val result = f(list.iterator())
+    return if (6 == result) "OK" else "fail"
+}

compiler/testData/codegen/boxWithStdlib/regressions/kt1172.kt

@@ -0,0 +1,13 @@
+package test.regressions.kt1172
+
+import kotlin.concurrent.*
+import java.util.*
+
+public fun scheduleRefresh(vararg files : Object) {
+    java.util.ArrayList<Object>(files.map{ it })
+}
+
+fun box(): String {
+    scheduleRefresh()
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/regressions/kt1202.kt

@@ -0,0 +1,116 @@
+package testeval
+
+import java.util.*
+
+trait Expression
+class Num(val value : Int) : Expression
+class Sum(val left : Expression, val right : Expression) : Expression
+class Mult(val left : Expression, val right : Expression) : Expression
+
+fun eval(e : Expression) : Int {
+    return when (e) {
+        is Num -> e.value
+        is Sum -> eval(e.left) + eval (e.right)
+        is Mult -> eval(e.left) * eval (e.right)
+        else -> throw AssertionError("Unknown expression")
+    }
+}
+
+trait ParseResult<out T> {
+    val success : Boolean
+    val value : T
+}
+
+class Success<T>(override val value : T) : ParseResult<T> {
+    public override val success : Boolean = true
+}
+
+class Failure(val message : String) : ParseResult<Nothing> {
+    override val success = false
+    override val value : Nothing = throw UnsupportedOperationException("Don't call value on a Failure")
+}
+
+open class Token(val text : String) {
+    override fun toString() = text
+}
+object LPAR : Token("(")
+object RPAR : Token(")")
+object PLUS : Token("+")
+object TIMES : Token("*")
+object EOF : Token("EOF")
+class Number(text : String) : Token(text)
+class Error(text : String) : Token("[Error: $text]")
+
+
+fun tokenize(text : String) : Deque<Token> {
+    val result = LinkedList<Token>()
+    for (c in text) {
+        result add when (c) {
+            '(' -> LPAR
+            ')' -> RPAR
+            '+' -> PLUS
+            '*' -> TIMES
+            in '0'..'9' -> Number(c.toString())
+            else -> Error(c.toString())
+        }
+    }
+    result.add(EOF)
+    return result
+}
+
+fun parseSum(tokens : Deque<Token>) : ParseResult<Expression> {
+    val left = parseMult(tokens)
+    if (!left.success) return left
+
+    if (tokens.peek() == PLUS) {
+        tokens.pop()
+        val right = parseSum(tokens)
+        if (!right.success) return right
+        return Success(Sum(left.value, right.value))
+    }
+
+    return left
+}
+
+fun parseMult(tokens : Deque<Token>) : ParseResult<Expression> {
+    val left = parseAtomic(tokens)
+    if (!left.success) return left
+
+    if (tokens.peek() == PLUS) {
+        tokens.pop()
+        val right = parseMult(tokens)
+        if (!right.success) return right
+        return Success(Mult(left.value, right.value))
+    }
+
+    return left
+}
+
+fun parseAtomic(tokens : Deque<Token>) : ParseResult<Expression> {
+    val token = tokens.poll()
+    return when (token) {
+        LPAR -> {
+            val result = parseSum(tokens)
+            val rpar = tokens.poll()
+            if (rpar == RPAR)
+                result
+            else
+                Failure("Expecting ')'")
+        }
+        is Number -> Success(Num(Integer.parseInt((token as Token).text)))
+        else -> Failure("Unexpected EOF")
+    }
+}
+
+fun parse(text : String) : ParseResult<Expression> = parseSum(tokenize(text))
+
+fun box(): String {
+    if (1 != eval(Num(1))) return "fail 1"
+    if (2 != eval(Sum(Num(1), Num(1)))) return "fail 2"
+    if (3 != eval(Mult(Num(3), Num(1)))) return "fail 3"
+    if (6 != eval(Mult(Num(3), Sum(Num(1), Num(1))))) return "fail 4"
+
+    if (1 != eval(parse("1").value)) return "fail 5"
+
+    return "OK"
+}