Merge remote branch 'origin/master'

Conflicts: idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
2011-09-02 13:26:38 +04:00
parent 6fd6ad2bea 496d3e472d
commit 6954977350
37 changed files with 855 additions and 109 deletions
@@ -0,0 +1,8 @@
+fun test() {
+  1 : Byte
+  1 : Int
+  <error>1</error> : Double
+  1 <warning>as</warning> Byte
+  1 <warning>as</warning> Int
+  1 <warning>as</warning> Double
+}
@@ -0,0 +1,40 @@
+package 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, any)</error>
+    copy2(ints, any) //ok
+    copy2<error>(ints, numbers)</error>
+    copy3<Int>(ints, numbers)
+    copy4(ints, numbers) //ok
+}
@@ -231,6 +231,8 @@ fun mergeAutocasts(a: Any?) {
  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>compareTo</error>("") == 0) {}
 }

 //mutability
@@ -0,0 +1,15 @@
+import java.lang.Integer
+
+class C {
+ fun f(): Any = "C f"
+}
+
+class D() : C {
+    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,10 @@
+class A() {
+    fun foo() {
+        System.out?.println(1)
+    }
+}
+
+fun box() : String {
+    val a : A = A()
+    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)
+    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,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,66 @@
+class A() {}
+class B<T>() {
+    fun isT (a : Any?) : Boolean {
+        return a is T
+    }
+}
+
+fun t1() : Boolean {
+    val a = A()
+    if(a !is A)   return false
+    if(a !is A?)   return false
+    if(null !is A?)   return false
+    return true
+}
+
+fun t2 () : Boolean {
+    val b = B<String>()
+    if(b !is B<String>)   return false
+    if(b !is B<String>?)  return false
+    if(null !is B<String>?)  return false
+
+    val v = b as B<String>   //ok
+    val u = b as B<String>?  //TypeCastException
+
+    val w : B<String>? = b as B<String>   //ok
+    val x = w as B<String>?  //TypeCastException
+    return true
+}
+
+fun t3 () : Boolean {
+    val b = B<String>()
+    if(!b.isT("aaa")) return false
+
+    if(b.isT(10))     return false
+    if(b.isT(null))   return false
+
+    val d = B<String?>()
+    if(!d.isT("aaa")) return false
+    if(d.isT(10))     return false
+    if(!d.isT(null))  return false
+
+    val c = B<Int>()
+    if(c.isT("aaa")) return false
+    if(!c.isT(10))   return false
+    if(c.isT(null)) return false
+
+    val e = B<Int?>()
+    if(e.isT("aaa")) return false
+    if(!e.isT(10))   return false
+    if(!e.isT(null)) return false
+
+    return true
+}
+
+fun box() : String {
+    if(!t1()) {
+        return "t1 failed"
+    }
+    if(!t2()) {
+        return "t2 failed"
+    }
+    if(!t3()) {
+        return "t3 failed"
+    }
+    return "OK"
+}