SI-1786 incorporate defined bounds in inference

Also fixes SI-5459.

Look, you don't have to redeclare the bounds, isn't it exciting?
For instance, there are eight places in JavaMirrors with this:

  jTypeVariable[_ <: GenericDeclaration]

After this code is in starr, those can look like this:

  jTypeVariable[_]

Since TypeVariable's definition looks like this:

  interface TypeVariable<D extends GenericDeclaration>

We already know that!

4 files changed, 21 insertions, 25 deletions

diff --git a/test/files/neg/t5687.check b/test/files/neg/t5687.check
index 5096077ee5..f8d02fdcc3 100644
--- a/test/files/neg/t5687.check
+++ b/test/files/neg/t5687.check
@@ -1,8 +1,5 @@
-t5687.scala:4: error: type arguments [T] do not conform to class Template's type parameter bounds [T <: AnyRef]
-  type Repr[T]<:Template[T]
-                ^
-t5687.scala:20: error: overriding type Repr in class Template with bounds[T] <: Template[T];
+t5687.scala:20: error: overriding type Repr in class Template with bounds[T <: AnyRef] <: Template[T];
  type Repr has incompatible type
   type Repr = CurveTemplate[T]
        ^
-two errors found
+one error found
diff --git a/test/files/pos/t1786.scala b/test/files/pos/t1786.scala
new file mode 100644
index 0000000000..22bd659609
--- /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.
-*/