Regression 2.13: implicit resolution and partial unification

[japgolly]

The following code works in 2.12.x but fails to compile on 2.13.1:

object Blah {

  trait TC[F[_]]

  final class Ops[F[_], A](m: F[A])(implicit p: TC[F]) {
    def example = 0
  }

  implicit def toTcOps[F[_], A](fa: F[A])(implicit tc: TC[F]): Ops[F, A] =
    new Ops[F, A](fa)(tc)

  final case class X[A]()

  implicit val tcX: TC[X] =
    new TC[X] {}

  object Example1 {
    type Y[A, B] = X[(A, B)] // both arguments used

    def woah[A, B](a: Y[A, B]) = {
      a.example                      // Error in 2.13 but ok in 2.12
      toTcOps(a).example             // Error in 2.13 but ok in 2.12
      toTcOps[X, (A, B)](a).example  // OK in 2.13 & 2.12
    }
  }

  object Example2 {
    type Y[A, B] = X[A] // phantom type

    def woah[A, B](a: Y[A, B]) = {
      a.example                 // Error in 2.13 but ok in 2.12
      toTcOps(a).example        // Error in 2.13 but ok in 2.12
      toTcOps[X, A](a).example  // OK in 2.13 & 2.12
    }
  }

}

Error:

[error] Blah.scala:21:9: value example is not a member of Blah.Example1.Y[A,B]
[error]       a.example                 // Error in 2.13 but ok in 2.12
[error]         ^
[error] Blah.scala:22:14: could not find implicit value for parameter tc: Blah.TC[[B]Blah.Example1.Y[A,B]]
[error]       toTcOps(a).example        // Error in 2.13 but ok in 2.12
[error]              ^
[error] Blah.scala:31:9: value example is not a member of Blah.Example2.Y[A,B]
[error]       a.example                 // Error in 2.13 but ok in 2.12
[error]         ^
[error] Blah.scala:32:14: could not find implicit value for parameter tc: Blah.TC[[B]Blah.Example2.Y[A,B]]
[error]       toTcOps(a).example        // Error in 2.13 but ok in 2.12
[error]              ^
[error] four errors found

[joroKr21]

The examples also fail on 2.12.10 with -Ypartial-unification which is unconditional in 2.13

[japgolly]

Thanks @joroKr21 , I forgot to mention that I have -Ypartial-unification on for 2.12 😁

[japgolly]

Hmm I just tried with on 2.12.10 without -Ypartial-unification and it compiles.

> scala  
Welcome to Scala 2.12.10 (OpenJDK 64-Bit GraalVM CE 19.2.0, Java 1.8.0_222).
Type in expressions for evaluation. Or try :help.

scala> object Blah {
     | 
     |   trait TC[F[_]]
     | 
     |   final class Ops[F[_], A](m: F[A])(implicit p: TC[F]) {
     |     def example = 0
     |   }
     | 
     |   implicit def toTcOps[F[_], A](fa: F[A])(implicit tc: TC[F]): Ops[F, A] =
     |     new Ops[F, A](fa)(tc)
     | 
     |   final case class X[A]()
     | 
     |   implicit val tcX: TC[X] =
     |     new TC[X] {}
     | 
     |   object Example1 {
     |     type Y[A, B] = X[(A, B)] // both arguments used
     | 
     |     def woah[A, B](a: Y[A, B]) = {
     |       a.example                      // Error in 2.13 but ok in 2.12
     |       toTcOps(a).example             // Error in 2.13 but ok in 2.12
     |       toTcOps[X, (A, B)](a).example  // OK in 2.13 & 2.12
     |     }
     |   }
     | 
     |   object Example2 {
     |     type Y[A, B] = X[A] // phantom type
     | 
     |     def woah[A, B](a: Y[A, B]) = {
     |       a.example                 // Error in 2.13 but ok in 2.12
     |       toTcOps(a).example        // Error in 2.13 but ok in 2.12
     |       toTcOps[X, A](a).example  // OK in 2.13 & 2.12
     |     }
     |   }
     | 
     | }
<console>:13: warning: higher-kinded type should be enabled
by making the implicit value scala.language.higherKinds visible.
This can be achieved by adding the import clause 'import scala.language.higherKinds'
or by setting the compiler option -language:higherKinds.
See the Scaladoc for value scala.language.higherKinds for a discussion
why the feature should be explicitly enabled.
         trait TC[F[_]]
                  ^
<console>:15: warning: higher-kinded type should be enabled
by making the implicit value scala.language.higherKinds visible.
         final class Ops[F[_], A](m: F[A])(implicit p: TC[F]) {
                         ^
<console>:19: warning: higher-kinded type should be enabled
by making the implicit value scala.language.higherKinds visible.
         implicit def toTcOps[F[_], A](fa: F[A])(implicit tc: TC[F]): Ops[F, A] =
                              ^
<console>:19: warning: implicit conversion method toTcOps should be enabled
by making the implicit value scala.language.implicitConversions visible.
This can be achieved by adding the import clause 'import scala.language.implicitConversions'
or by setting the compiler option -language:implicitConversions.
See the Scaladoc for value scala.language.implicitConversions for a discussion
why the feature should be explicitly enabled.
         implicit def toTcOps[F[_], A](fa: F[A])(implicit tc: TC[F]): Ops[F, A] =
                      ^
defined object Blah

[japgolly]

I also tried it on the following and it compiles successfully without -Ypartial-unification:

• 2.12.2
• 2.12.3
• 2.12.4
• 2.12.8
• 2.12.10

[joroKr21]

Yes I meant that it fails with -Ypartial-unification on, i.e. it's the result of partial unifcation.
Because the compiler will accept Y[A, *] instead of searching in the supertypes and finding X.

[SethTisue]

@milessabin ring a bell?

[milessabin]

I think that @joroKr21 has diagnosed the issue.

[japgolly]

Hi. Is someone able to tag this with the regression label? It seems I don't have access to.

[japgolly]

(Thanks @lrytz)

[japgolly]

This is issue is a huge blocker to me because it completely prevents downstream usage of
https://github.com/japgolly/test-state

Is there something I can do to get this resolved for 2.13.2?
I'd be happy to even try my hand at a PR to resolve but if someone's able to maybe help guide me...? I'm afraid I don't know the compiler internals very well at all. Please let me know how I can help. Cheers.

[joroKr21]

But that's just how partial unification works. The only "fix" I can think of is to make implicit search influence unification but I don't know if that's feasible or desirable.