Fix #7139: Implement kind-projector compatibility

  - Support * placeholder (including in tuple and function types)
  - Support λ alternative to =>> syntax
  - Add tests

Author: travisbrown

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -610,6 +610,7 @@ object StdNames {
       final val BAR  : N  = "|"
       final val DOLLAR: N = "$"
       final val GE: N     = ">="
+      final val LAMBDA: N = "λ"
       final val LE: N     = "<="
       final val MINUS: N  = "-"
       final val NE: N     = "!="

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1322,8 +1322,19 @@ object Parsers {
       def functionRest(params: List[Tree]): Tree =
         atSpan(start, accept(ARROW)) {
           val t = typ()
+
           if (imods.isOneOf(Given | Erased)) new FunctionWithMods(params, t, imods)
-          else Function(params, t)
+          else if (ctx.settings.YkindProjector.value) {
+            val (newParams :+ newT, tparams) = replaceKindProjectorPlaceholders(params :+ t)
+
+            if (tparams.isEmpty) {
+              Function(params, t)
+            } else {
+              LambdaTypeTree(tparams, Function(newParams, newT))
+            }
+          } else {
+            Function(params, t)
+          }
         }
       def funArgTypesRest(first: Tree, following: () => Tree) = {
         val buf = new ListBuffer[Tree] += first
@@ -1413,6 +1424,23 @@ object Parsers {
       }
     }
 
+    /** Replaces kind-projector's `*` in a list of types arguments with synthetic names,
+     *  returning the new argument list and the synthetic type definitions.
+     */
+    private def replaceKindProjectorPlaceholders(params: List[Tree]): (List[Tree], List[TypeDef]) = {
+      val tparams = new ListBuffer[TypeDef]
+
+      val newParams = params.map {
+        case Ident(tpnme.raw.STAR) =>
+          val name = tpnme.syntheticTypeParamName(tparams.length)
+          tparams += TypeDef(name, TypeBoundsTree(EmptyTree, EmptyTree))
+          Ident(name)
+        case other => other
+      }
+
+      (newParams, tparams.toList)
+    }
+
     private def implicitKwPos(start: Int): Span =
       Span(start, start + nme.IMPLICITkw.asSimpleName.length)
 
@@ -1529,7 +1557,6 @@ object Parsers {
         typeBounds().withSpan(Span(start, in.lastOffset, start))
       }
       else if (isIdent(nme.*) && ctx.settings.YkindProjector.value) {
-        syntaxError("`*` placeholders are not implemented yet")
         typeIdent()
       }
       else if (isSplice)
@@ -1550,8 +1577,60 @@ object Parsers {
     private def simpleTypeRest(t: Tree): Tree = in.token match {
       case HASH => simpleTypeRest(typeProjection(t))
       case LBRACKET => simpleTypeRest(atSpan(startOffset(t)) {
-        AppliedTypeTree(rejectWildcardType(t), typeArgs(namedOK = false, wildOK = true)) })
-      case _ => t
+        val applied = rejectWildcardType(t)
+        val args = typeArgs(namedOK = false, wildOK = true)
+
+        if (ctx.settings.YkindProjector.value) {
+          def fail(): Tree = {
+            syntaxError(
+              "λ requires a single argument of the form X => ... or (X, Y) => ...",
+              Span(t.span.start, in.lastOffset)
+            )
+            AppliedTypeTree(applied, args)
+          }
+
+          applied match {
+            case Ident(tpnme.raw.LAMBDA) =>
+              args match {
+                case List(Function(params, body)) =>
+                  val typeDefs = params.collect {
+                    case Ident(name) => TypeDef(name.toTypeName, TypeBoundsTree(EmptyTree, EmptyTree))
+                  }
+                  if (typeDefs.length != params.length) fail()
+                  else LambdaTypeTree(typeDefs, body)
+                case _ =>
+                  fail()
+              }
+            case _ =>
+              val (newArgs, tparams) = replaceKindProjectorPlaceholders(args)
+
+              if (tparams.isEmpty) {
+                AppliedTypeTree(applied, args)
+              } else {
+                LambdaTypeTree(tparams, AppliedTypeTree(applied, newArgs))
+              }
+          }
+
+        } else {
+          AppliedTypeTree(applied, args)
+        }
+      })
+      case _ =>
+        if (ctx.settings.YkindProjector.value) {
+          t match {
+            case Tuple(params) =>
+              val (newParams, tparams) = replaceKindProjectorPlaceholders(params)
+
+              if (tparams.isEmpty) {
+                t
+              } else {
+                LambdaTypeTree(tparams, Tuple(newParams))
+              }
+            case _ => t
+          }
+        } else {
+          t
+        }
     }
 
     private def typeProjection(t: Tree): Tree = {

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -16,7 +16,8 @@ object TestConfiguration {
     "-Yno-deep-subtypes",
     "-Yno-double-bindings",
     "-Yforce-sbt-phases",
-    "-Xverify-signatures"
+    "-Xverify-signatures",
+    "-Ykind-projector"
   )
 
   val basicClasspath = mkClasspath(List(

tests/neg/kind-projector.check

@@ -0,0 +1,12 @@
+-- Error: tests/neg/kind-projector.scala:7:23 --------------------------------------------------------------------------
+7 |class Bar3 extends Foo[λ[List[x] => Int]] // error
+  |                       ^^^^^^^^^^^^^^^^^
+  |                       λ requires a single argument of the form X => ... or (X, Y) => ...
+-- Error: tests/neg/kind-projector.scala:5:23 --------------------------------------------------------------------------
+5 |class Bar1 extends Foo[Either[*, *]] // error
+  |                       ^^^^^^^^^^^^
+  |                       Type argument Either has not the same kind as its bound  <: [_$1] => Any
+-- Error: tests/neg/kind-projector.scala:6:22 --------------------------------------------------------------------------
+6 |class Bar2 extends Foo[*] // error
+  |                      ^
+  |                      Type argument X0 has not the same kind as its bound  <: [_$1] => Any

tests/neg/kind-projector.scala

@@ -0,0 +1,7 @@
+package kind_projector_neg
+
+trait Foo[F[_]]
+
+class Bar1 extends Foo[Either[*, *]] // error
+class Bar2 extends Foo[*] // error
+class Bar3 extends Foo[λ[List[x] => Int]] // error

tests/pos/kind-projector.scala

@@ -0,0 +1,15 @@
+package kind_projector
+
+trait Foo[F[_]]
+trait Qux[F[_, _]]
+trait Baz[F[_], A, B]
+
+class Bar1 extends Foo[Either[Int, *]]
+class Bar2 extends Foo[Either[*, Int]]
+class Bar3 extends Foo[* => Int]
+class Bar4 extends Foo[Int => *]
+class Bar5 extends Foo[(Int, *, Int)]
+class Bar6 extends Foo[λ[x => Either[Int, x]]]
+class Bar7 extends Qux[λ[(x, y) => Either[y, x]]]
+class Bar8 extends Foo[Baz[Int => *, *, Int]]
+class Bar9 extends Foo[λ[x => Baz[x => *, Int, x]]]