Added test case from SI-6169

Author: odersky

tests/pos/wildcardBoundInference.scala

@@ -0,0 +1,69 @@
+// Tests translated from scalac SI-6189 by @retronym
+
+/*
+public class Exist<T extends String> {
+  // java helpfully re-interprets Exist<?> as Exist<? extends String>
+  public Exist<?> foo() { throw new RuntimeException(); }
+}
+*/
+class Exist[T <: String] {
+  def foo: Exist[_] = null
+}
+
+/*
+public class ExistF<T extends ExistF<T>> {
+  // java helpfully re-interprets ExistF<?> as ExistF<?0 extends ExistF<?0>>
+  public ExistF<?> foo() { throw new RuntimeException(); }
+}
+*/
+
+class ExistF[T <: ExistF[T]] {
+  def foo: ExistF[_] = null
+}
+
+/*
+public class ExistIndir<T extends String, U extends T> {
+  // java helpfully re-interprets ExistIndir<?> as ExistIndir<? extends String>
+  public ExistIndir<?, ?> foo() { throw new RuntimeException(); }
+}
+*/
+
+class ExistIndir[T <: String, U <: T] {
+  def foo: ExistIndir[_, _] = null
+}
+
+class Test {
+  class MyExist extends ExistF[MyExist]
+  // SI-8197, SI-6169: java infers the bounds of existentials, so we have to as well now that SI-1786 is fixed...
+  def stringy: Exist[_ <: String] = (new Exist[String]).foo
+  // def fbounded: (ExistF[t] forSome {type t <: ExistF[t] }) = (new MyExist).foo
+  def indir: ExistIndir[_ <: String, _ <: String] = (new ExistIndir[String, String]).foo
+}
+
+
+/*
+public abstract class OP<T> { }
+public interface Skin<C extends Skinnable> { }
+public interface Skinnable {
+  OP<Skin<?>> skinProperty();
+}
+*/
+class OP[T]
+trait Skin[C <: Skinnable]
+trait Skinnable {
+  def skinProperty: OP[Skin[_]]
+}
+object ObjectProperty {
+  implicit def jfxObjectProperty2sfx[T](p: OP[T]): ObjectProperty[T] = new ObjectProperty[T](p)
+}
+
+class ObjectProperty[T](val delegate: OP[T])
+
+trait TestWildcardBoundInference {
+  def delegate: Skinnable
+  def skin: ObjectProperty[Skin[_ /* inferred: <: Skinnable */]] = ObjectProperty.jfxObjectProperty2sfx(delegate.skinProperty)
+  skin: ObjectProperty[Skin[_  <: Skinnable]]
+
+  def skinCheckInference = delegate.skinProperty
+  skinCheckInference: ObjectProperty[Skin[_  <: Skinnable]]
+}