SI-6169 Refine java wildcard bounds using corresponding tparam

src/reflect/scala/reflect/internal/Types.scala

@@ -899,7 +899,7 @@ trait Types
       -1
     }
 
-    /** If this is a poly- or methodtype, a copy with cloned type / value parameters
+    /** If this is a ExistentialType, PolyType or MethodType, a copy with cloned type / value parameters
      *  owned by `owner`. Identity for all other types.
      */
     def cloneInfo(owner: Symbol) = this
@@ -2656,8 +2656,55 @@ trait Types
     override def baseTypeSeq = underlying.baseTypeSeq map maybeRewrap
     override def isHigherKinded = false
 
-    override def skolemizeExistential(owner: Symbol, origin: AnyRef) =
+    /** [SI-6169, SI-8197 -- companion to SI-1786]
+     *
+     *   Approximation to improve the bounds of a Java-defined existential type,
+     *   based on the bounds of the type parameters of the quantified type
+     *   In Scala syntax, given a java-defined class C[T <: String], the existential type C[_]
+     *   is improved to C[_ <: String] before skolemization, which captures (get it?) what Java does:
+     *   enter the type paramers' bounds into the context when checking subtyping/type equality of existential types
+     *
+     *   (Also tried doing this once during class file parsing or when creating the existential type,
+     *   but that causes cyclic errors because it happens too early.)
+     */
+    private def sharpenQuantifierBounds(): Unit = {
+      /* Check that we're looking at rawToExistential's handiwork
+       * (`existentialAbstraction(eparams, typeRef(apply(pre), sym, eparams map (_.tpe)))`).
+       * We can't do this sharpening there because we'll run into cycles.
+       */
+      def rawToExistentialCreatedMe = (quantified corresponds underlying.typeArgs){ (q, a) => q.tpe =:= a }
+
+      if (underlying.typeSymbol.isJavaDefined && rawToExistentialCreatedMe) {
+        val tpars = underlying.typeSymbol.initialize.typeParams // TODO: is initialize needed?
+        debuglog(s"sharpen bounds: $this | ${underlying.typeArgs.map(_.typeSymbol)} <-- ${tpars.map(_.info)}")
+
+        foreach2(quantified, tpars) { (quant, tparam) =>
+          // TODO: check `tparam.info.substSym(tpars, quantified) <:< quant.info` instead (for some weird reason not working for test/t6169/ExistF)
+          // for now, crude approximation for the common case
+          if (quant.info.bounds.isEmptyBounds && !tparam.info.bounds.isEmptyBounds) {
+            // avoid creating cycles [pos/t2940] that consist of an existential quantifier's
+            // bounded by an existential type that unhygienically has that quantifier as its own quantifier
+            // (TODO: clone latter existential with fresh quantifiers -- not covering this case for now)
+            if ((existentialsInType(tparam.info) intersect quantified).isEmpty)
+              quant setInfo tparam.info.substSym(tpars, quantified)
+          }
+        }
+      }
+
+      _sharpenQuantifierBounds = false
+    }
+    private[this] var _sharpenQuantifierBounds = true
+
+    override def skolemizeExistential(owner: Symbol, origin: AnyRef) = {
+      // do this here because it's quite close to what Java does:
+      // when checking subtyping/type equality, enter constraints
+      // derived from the existentially quantified type into the typing environment
+      // (aka \Gamma, which tracks types for variables and constraints/kinds for types)
+      // as a nice bonus, delaying this until we need it avoids cyclic errors
+      if (_sharpenQuantifierBounds) sharpenQuantifierBounds
+
       deriveType(quantified, tparam => (owner orElse tparam.owner).newExistentialSkolem(tparam, origin))(underlying)
+    }
 
     private def wildcardArgsString(qset: Set[Symbol], args: List[Type]): List[String] = args map {
       case TypeRef(_, sym, _) if (qset contains sym) =>

test/files/pos/t6169/Exist.java

@@ -0,0 +1,4 @@
+public class Exist<T extends String> {
+  // java helpfully re-interprets Exist<?> as Exist<? extends String>
+  public Exist<?> foo() { throw new RuntimeException(); }
+}

test/files/pos/t6169/ExistF.java

@@ -0,0 +1,4 @@
+public class ExistF<T extends ExistF<T>> {
+  // java helpfully re-interprets ExistF<?> as ExistF<?0 extends ExistF<?0>>
+  public ExistF<?> foo() { throw new RuntimeException(); }
+}

test/files/pos/t6169/ExistIndir.java

@@ -0,0 +1,4 @@
+public class ExistIndir<T extends String, U extends T> {
+  // java helpfully re-interprets ExistIndir<?> as ExistIndir<? extends String>
+  public ExistIndir<?, ?> foo() { throw new RuntimeException(); }
+}

test/files/pos/t6169/OP.java

@@ -0,0 +1 @@
+public abstract class OP<T> { }

test/files/pos/t6169/Skin.java

@@ -0,0 +1 @@
+public interface Skin<C extends Skinnable> { }

test/files/pos/t6169/Skinnable.java

@@ -0,0 +1,3 @@
+public interface Skinnable {
+  OP<Skin<?>>	skinProperty();
+}

test/files/pos/t6169/skinnable.scala

@@ -0,0 +1,14 @@
+object ObjectProperty {
+  implicit def jfxObjectProperty2sfx[T](p: OP[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]]
+}

test/files/pos/t6169/t6169.scala

@@ -0,0 +1,7 @@
+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
+}