HK type variable in head position of type application should be instantiated to allow member selection

[djspiewak]

Another one from this commit: typelevel/cats-effect@ef891ca Odds seem good this one is easier to minimize…

In this snippet, I have to have the ioa val:

    "allocate does not release until close is invoked" in ticked { implicit ticker =>
      val released = new java.util.concurrent.atomic.AtomicBoolean(false)
      val release = Resource.make(IO.unit)(_ => IO(released.set(true)))
      val resource = Resource.liftF(IO.unit)

      // do not inline: it confuses Dotty
      val ioa = (release *> resource).allocated

      val prog = for {
        res <- ioa
        (_, close) = res
        _ <- IO(released.get() must beFalse)
        _ <- close
        _ <- IO(released.get() must beTrue)
      } yield ()

      prog must completeAs(())
    }

If I inline ioa into the for-comprehension, I get the following error:

[error] -- [E008] Not Found Error: /Users/daniel/Development/Scala/cats-effect/series-3.x/core/shared/src/test/scala/cats/effect/ResourceSpec.scala:187:15 
[error] 187 |        res <- (release *> resource).allocated
[error]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[error]     |value map is not a member of cats.effect.IO[(Unit, cats.effect.IO[Unit])], but could be made available as an extension method.
[error]     |
[error]     |One of the following imports might make progress towards fixing the problem:

Hilariously, map is actually a direct member of cats.effect.IO. There should be no implicit resolution involved at all. I ran into this problem in a couple places, and pulling the expression out into a value solved it every time.

[griggt]

Minimized:

trait Foo[F[_]] {
  def foo[G[x] >: F[x]]: G[Unit]
}

trait M[A] {
  def flatMap[B](f: A => M[B]): M[B]
  def map[B](f: A => B): M[B]
}

def bar(x: Foo[M]): Unit = {
  for {
    _ <- x.foo
  } yield ()
}

output from dotty 0.27.0-RC1:

[error] -- [E008] Not Found Error: /src/i9567/src/main/scala/Main.scala:12:9 -----------
[error] 12 |    _ <- x.foo
[error]    |         ^^^^^
[error]    |        value map is not a member of M[Unit] - did you mean M[Unit].map?

The workaround:

trait Foo[F[_]] {
  def foo[G[x] >: F[x]]: G[Unit]
}

trait M[A] {
  def flatMap[B](f: A => M[B]): M[B]
  def map[B](f: A => B): M[B]
}

def bar(x: Foo[M]): Unit = {
  val a = x.foo
  for {
    _ <- a
  } yield ()

sbt:i9567> compile
[success] Total time: 0 s, completed Sep 17, 2020, 4:12:15 PM

[djspiewak]

My sincerest admiration for that minimization effort!

[smarter]

Thanks! Minimized a bit more:

trait Foo[F[_]] {
  def foo[G[x] >: F[x]]: G[Unit]
}

trait M[A] {
  def bla: Int = 1
  def baz(f: Int => Int): Int = f(1)
}

object Test {
  def bar(x: Foo[M]): Unit = {
    // error: value bla is not a member of G[Unit],
    // where:    G is a type variable with constraint >: M and <: [x] =>> Any
    x.foo.bla

    // error: value baz is not a member of M[Unit] - did you mean M[Unit].baz?
    x.foo.baz(x => x)
  }
}

The second error message doesn't make sense indeed, but I think it's an artifact of it printing types after G has been instantiated to M. The first error message is clearer: the issue is that at the point where we call bla, we don't actually know which members we have because our prefix has type ?G[Unit] where ?G hasn't been instantiated yet. We need to tweak type inference to make sure the type constructor of an application is always instantiated before trying to select something on it (and we need to see if we can tweak the error reporting process to avoid this sort of confusion, there's already code to handle this sort of things but evidently not enough: https://github.com/lampepfl/dotty/blob/04659bec64d98cc483c9288f91b04a5b274989bb/compiler/src/dotty/tools/dotc/typer/Inferencing.scala#L491-L510)