Incorrect kind check error

[Odomontois]

reproduction steps

using Scala 2.13.3, compile the following code

abstract class Expr[-S[-l[-_, +_], +f[-_, +_]], -I, +O] extends Unindexed[S] {
  def fold[F[-_, +_]](matcher: S[Expr[S, -*, +*], F]): F[I, O]

  final override def foldU[F[-_, +_]]( matcher: S[Unindexed.Inner[S, -*, +*], F]): F[Nothing, Any] = 
     fold(matcher)
}


trait Unindexed[-S[-l[-_, +_], +f[-_, +_]]] {
  def foldU[F[-i, +o]](matcher: S[Unindexed.Inner[S, -*, +*], F]): F[Nothing, Any]
}

object Unindexed {
  type Inner[-S[-l[-_, +_], +f[-_, +_]], -I, +O] = Unindexed[S]
}

problem

Compilation fails with error

type F takes type parameters

at the definition of the Unindexed.foldU

Change the order of two definitions to

trait Unindexed[-S[-l[-_, +_], +f[-_, +_]]] {
  def foldU[F[-i, +o]](matcher: S[Unindexed.Inner[S, -*, +*], F]): F[Nothing, Any]
}

object Unindexed {
  type Inner[-S[-l[-_, +_], +f[-_, +_]], -I, +O] = Unindexed[S]
}

abstract class Expr[-S[-l[-_, +_], +f[-_, +_]], -I, +O] extends Unindexed[S] {
  def fold[F[-_, +_]](matcher: S[Expr[S, -*, +*], F]): F[I, O]

  final override def foldU[F[-_, +_]](matcher: S[Unindexed.Inner[S, -*, +*], F]): F[Nothing, Any] = 
     fold(matcher)
}

makes error disappear

[hrhino]

I don't know how this issue got so many 😕 emoji in only a few hours, but I have to agree.

[SethTisue]

Is this minimized?

Does Dotty accept it?

I don't want to get your hopes up about someone volunteering to investigate/fix, but I think the best way to increase the chances of that would be to minimize it further. The current code is quite hairy.

The order-dependence is indeed.... sad.

[dwijnand]

Minimised:

$ m t12187.scala
object Z {
   type Baz[S[_[_], _[_]], _] = Bar[S]
  trait Foo[S[_[_], _[_]]   ] extends Bar[S] { def m[F[_]](x: S[Baz[S, *], F]): Unit }
  trait Bar[S[_[_], _[_]]   ]                { def m[F[_]](x: S[Baz[S, *], F]): Unit }
}
$ scalac -2.13.4 -Xplugin:$(cs fetch -p org.typelevel:kind-projector_2.13.4:0.11.2) t12187.scala
t12187.scala:4: error: type F takes type parameters
  trait Bar[S[_[_], _[_]]   ]                { def m[F[_]](x: S[Baz[S, *], F]): Unit }
                                                                           ^
1 error

[dwijnand]

Dotty (3.0.0-M2) compiles my minimisation:

$ m t12187.scala
object Z {
   type Baz[S[_[_], _[_]], _] = Bar[S]
  trait Foo[S[_[_], _[_]]   ] extends Bar[S] { def m[F[_]](x: S[Baz[S, *], F]): Unit }
  trait Bar[S[_[_], _[_]]   ]                { def m[F[_]](x: S[Baz[S, *], F]): Unit }
}
$ scalac3 -Ykind-projector t12187.scala
-- Warning: t12187.scala:3:2 ---------------------------------------------------
3 |  trait Foo[S[_[_], _[_]]   ] extends Bar[S] { def m[F[_]](x: S[Baz[S, *], F]): Unit }
  |  ^
  |  Line is indented too far to the left, or a `}` is missing
-- Warning: t12187.scala:4:2 ---------------------------------------------------
4 |  trait Bar[S[_[_], _[_]]   ]                { def m[F[_]](x: S[Baz[S, *], F]): Unit }
  |  ^
  |  Line is indented too far to the left, or a `}` is missing
2 warnings found

but it looks like its -Ykind-projector isn't doesn't cover the syntax used in the original:

$ scalac3 -Ykind-projector t12187.orig.scala
-- [E006] Not Found Error: t12187.orig.scala:2:41 ------------------------------
2 |  def fold[F[-_, +_]](matcher: S[Expr[S, -*, +*], F]): F[I, O]
  |                                         ^^
  |                                         Not found: type -*

longer explanation available when compiling with `-explain`
-- [E006] Not Found Error: t12187.orig.scala:2:45 ------------------------------
2 |  def fold[F[-_, +_]](matcher: S[Expr[S, -*, +*], F]): F[I, O]
  |                                             ^^
  |                                             Not found: type +*

longer explanation available when compiling with `-explain`
-- [E006] Not Found Error: t12187.orig.scala:4:69 ------------------------------
4 |  final override def foldU[F[-_, +_]]( matcher: S[Unindexed.Inner[S, -*, +*], F]): F[Nothing, Any] =
  |                                                                     ^^
  |                                                        Not found: type -*

longer explanation available when compiling with `-explain`
-- [E006] Not Found Error: t12187.orig.scala:4:73 ------------------------------
4 |  final override def foldU[F[-_, +_]]( matcher: S[Unindexed.Inner[S, -*, +*], F]): F[Nothing, Any] =
  |                                                                         ^^
  |                                                        Not found: type +*

longer explanation available when compiling with `-explain`
-- [E006] Not Found Error: t12187.orig.scala:10:53 -----------------------------
10 |  def foldU[F[-i, +o]](matcher: S[Unindexed.Inner[S, -*, +*], F]): F[Nothing, Any]
   |                                                     ^^
   |                                                     Not found: type -*

longer explanation available when compiling with `-explain`
-- [E006] Not Found Error: t12187.orig.scala:10:57 -----------------------------
10 |  def foldU[F[-i, +o]](matcher: S[Unindexed.Inner[S, -*, +*], F]): F[Nothing, Any]
   |                                                         ^^
   |                                                      Not found: type +*

longer explanation available when compiling with `-explain`
6 errors found

[joroKr21]

Here is a minimization without kind-projector:

object Z {
  trait Foo[S[_[_], _[_]]] extends Bar[S] {
    def m[F[_]](x: S[({ type G[A] = Bar[S] })#G, F]): Unit
  }
  trait Bar[S[_[_], _[_]]] {
    def m[F[_]](x: S[({ type G[A] = Bar[S] })#G, F]): Unit
  }
}

It looks like the method def completeTypeParams does not actually complete anything.
It's calling rawInfo load this with the default def load(sym: Symbol): Unit = {}.
TypeCompleters don't override load as complete whereas SymbolLoaders do.
It's all very confusing ...

[joroKr21]

Obviously reordering the definitions makes it work because Bar gets completed before Foo:

object Z {
  trait Bar[S[_[_], _[_]]] {
    def m[F[_]](x: S[({ type G[A] = Bar[S] })#G, F]): Unit
  }
  trait Foo[S[_[_], _[_]]] extends Bar[S] {
    def m[F[_]](x: S[({ type G[A] = Bar[S] })#G, F]): Unit
  }
}