Method type parameters not inferred when used in contravariant class type param

[nicolasstucki]

object A {
  def fun[E](a: A[E]): Unit = ()
  fun(new A[Int])
}
class A[-X]

Gets the following code

result of Foo.scala after frontend:

package <empty> {
  final lazy module val A: A$ = new A$()
  final module class A$() extends Object() { this: A.type => 
    def fun[E](a: A[E]): Unit = ()
    A.fun[Nothing](new A[Int]())   // <===========  Nothing is inferred where Int should
  }
  class A[X]() extends Object() { 
    <contravariant> type -X
    private[this] <contravariant> type -X =- X
  }
}

It also looks like #2671 and #2418 because of the contravariance of the arguments in the functions.

[nicolasstucki]

Note that inferring Nothing is correct as the effective bounds of E are Nothing <: E <: Int.

The issue is that any unconstrained use of E (such as implicit parameters and in the return type) may use Nothing where one expects Int.

[nicolasstucki]

Where are two other test cases that show the issue with some nesting.

object A {
  def funAC[E](a: A[C[E]]): Unit = ()
  def funCA[E](a: C[A[E]]): Unit = ()

  funAC(new A[C[Int]])
  funCA(new C[A[Int]])
}
class A[-X]
class C[+X]

result of Foo.scala after frontend:

package <empty> {
  final lazy module val A: A$ = new A$()
  final module class A$() extends Object() { this: A.type =>
    def funAC[E](a: A[C[E]]): Unit = ()
    def funCA[E](a: C[A[E]]): Unit = ()
    A.funAC[Nothing](new A[C[Int]]())
    A.funCA[Nothing](new C[A[Int]]())
  }
  ...
}

In both cases the bounds of E are Nothing <: E <: Int.

[nicolasstucki]

After offline discussions with @odersky and @DarkDimius we settled on the following rule to infer upper bounds:

• if the type parameter has only an upper bound constraint (no lower bound), then the type is inferred to the upper bound of the constraint bounds.

This logic should be added to OrderingConstraint.

[nicolasstucki]

Fixing this issue can potentially close 3 issues.