Merge pull request #2518 from paulp/issue/1786

SI-1786 incorporate defined bounds in inference

3 files changed, 19 insertions, 20 deletions

diff --git a/test/files/pos/t1786.scala b/test/files/pos/t1786.scala
new file mode 100644
index 0000000000..32d6c06f6e
--- /dev/null
+++ b/test/files/pos/t1786.scala
@@ -0,0 +1,19 @@
+class SomeClass(val intValue:Int)
+class MyClass[T <: SomeClass](val myValue:T)
+class Flooz[A >: Null <: SomeClass, T >: Null <: A](var value: T)
+
+class A {
+  def f1(i:MyClass[_])                       = i.myValue.intValue
+  def f2(i:MyClass[_ <: SomeClass])          = i.myValue.intValue
+  // def f3[T](i: MyClass[T])                   = i.myValue.intValue
+  def f4[T <: SomeClass](i: MyClass[T])      = i.myValue.intValue
+  // def f5[T >: Null](i: MyClass[T])           = i.myValue.intValue
+  // def f6[T >: Null <: String](i: MyClass[T]) = i.myValue.intValue + i.myValue.charAt(0)
+
+  // def g1[A, T](x: Flooz[A, T]) = { x.value = null ; x.value.intValue }
+  def g2(x: Flooz[_, _]) = { x.value = null ; x.value.intValue }
+
+  class MyClass2(x: MyClass[_]) { val p = x.myValue.intValue }
+  // class MyClass3[T <: String](x: MyClass[T]) { val p = x.myValue.intValue + x.myValue.length }
+  // class MyClass4[T >: Null](x: MyClass[T]) { val p = x.myValue.intValue }
+}
diff --git a/test/pending/pos/t5459.scala b/test/files/pos/t5459.scala
index 971e6f896d..971e6f896d 100644
--- a/test/pending/pos/t5459.scala
+++ b/test/files/pos/t5459.scala
diff --git a/test/pending/pos/t1786.scala b/test/pending/pos/t1786.scala
deleted file mode 100644
index dca2edaab4..0000000000
--- a/test/pending/pos/t1786.scala
+++ /dev/null
@@ -1,20 +0,0 @@
-/** This a consequence of the current type checking algorithm, where bounds
- *  are checked only after variables are instantiated. I believe this will change once we go to contraint-based type inference. Assigning low priority until then.
- * 
- *
- */
-class SomeClass(val intValue:Int)
-class MyClass[T <: SomeClass](val myValue:T) 
-
-object Test extends Application {
-  def myMethod(i:MyClass[_]) {
-    i.myValue.intValue/2      // << error i is of type Any
-  }
-
-  def myMethod(i:MyClass[_ <: SomeClass]) {
-    i.myValue.intValue/2      // << works
-  }
-}
-/*
-The below code shows a compiler flaw in that the wildcard "_" as value for a bounded type parameter either breaks the boundry - as it result in Any - or doesnt (as id hoped it to be) evaluates to the boundy.
-*/