Type inference issue involve type alias and higher-kinded type

As discussed in https://gitter.im/lampepfl/dotty?at=6033a71be634904e60b71e22

Compiler version

3.0.0-RC1

Minimized code

trait Functor[F[_]] {
  def map[A, B](fa: F[A]): F[B]
}

object data {

  opaque type OptionT[F[_], A] = F[Option[A]]

  extension [F[_], A](value: OptionT[F, A]) {

    def fold[B](default: => B)(f: A => B)(using F: Functor[F]): F[B] =
      F.map(value)(_.fold(default)(f))

    def cata[B](default: => B, f: A => B)(using x: Functor[F]): F[B] =
      fold(default)(f)(using x)
  }

}

Output

Compiler error
[error] -- [E050] Type Error: /Users/tim/dev/cheetahs/core/src/main/scala/io/github/timwspence/cheetahs/data.scala:30:11
[error] 30 |      F.map(value)(_.fold(default)(f))
[error]    |      ^^^^^^^^^^^^
[error]    |      method map in trait Functor does not take more parameters
[error] -- [E007] Type Mismatch Error: /Users/tim/dev/cheetahs/core/src/main/scala/io/github/timwspence/cheetahs/data.scala:33:29
[error] 33 |      fold(default)(f)(using x)
[error]    |                             ^
[error]    |Found:    (x : io.github.timwspence.cheetahs.Functor[F])
[error]    |Required: io.github.timwspence.cheetahs.Functor[F²]
[error]    |
[error]    |where:    F  is a type in method cata with bounds <: [_$3] =>> Any
[error]    |          F² is a type variable with constraint >: [X0] =>> io.github.timwspence.cheetahs.data.OptionT[F, X0] | F[X0] and <: [_$3] =>> Any

[smarter]

First, the compiler dealiases the second G.

Before we dealias, we should be compared the applied types as written, it looks like this is done but failing, looking around this seems to fix it:

diff --git compiler/src/dotty/tools/dotc/core/TypeComparer.scala compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 23cd8b25d25..46c3be62047 100644
--- compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -973,7 +973,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       /** True if `tp1` and `tp2` have compatible type constructors and their
        *  corresponding arguments are subtypes relative to their variance (see `isSubArgs`).
        */
-      def isMatchingApply(tp1: Type): Boolean = tp1 match {
+      def isMatchingApply(tp1: Type): Boolean = tp1.widen match {
         case tp1 @ AppliedType(tycon1, args1) =>
           // We intentionally do not automatically dealias `tycon1` or `tycon2` here.
           // `TypeApplications#appliedTo` already takes care of dealiasing type

now running the tests to see if this break anything, but this looks promising 😃

[smarter]

Minimized without the cats dependency:

trait Functor[F[_]]

object data {

  type OptionT[F[_], A] = F[Option[A]]

  def fold[F[_], A, B](value: OptionT[F, A])(f: Functor[F]): F[B] = ???

  def cata[F[_], A, B](value: OptionT[F, A])(f: Functor[F]): F[B] =
    fold(value)(f) // error
}

This compiles with Scala 2.