Fix #5965: Make scala.quoted.Type poly-kinded

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/QuotedOpsImpl.scala

@@ -14,38 +14,32 @@ trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with CoreImpl {
     def unseal(implicit ctx: Context): Term = PickledQuotes.quotedExprToTree(x)
   }
 
-  def QuotedTypeDeco[T](x: scala.quoted.Type[T]): QuotedTypeAPI = new QuotedTypeAPI {
-    def unseal(implicit ctx: Context): TypeTree = PickledQuotes.quotedTypeToTree(x)
-  }
-
-  def TermToQuoteDeco(term: Term): TermToQuotedAPI = new TermToQuotedAPI {
-
-    def seal[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T] = {
-
-      val expectedType = QuotedTypeDeco(implicitly[scala.quoted.Type[T]]).unseal.tpe
-
-      def etaExpand(term: Term): Term = term.tpe.widen match {
-        case mtpe: Types.MethodType if !mtpe.isParamDependent =>
-          val closureResType = mtpe.resType match {
-            case t: Types.MethodType => t.toFunctionType()
-            case t => t
-          }
-          val closureTpe = Types.MethodType(mtpe.paramNames, mtpe.paramInfos, closureResType)
-          val closureMethod = ctx.newSymbol(ctx.owner, nme.ANON_FUN, Synthetic | Method, closureTpe)
-          tpd.Closure(closureMethod, tss => etaExpand(new tpd.TreeOps(term).appliedToArgs(tss.head)))
-        case _ => term
-      }
+  protected def unsealType(tpe: quoted.Type[_])(implicit ctx: Context): TypeTree =
+    PickledQuotes.quotedTypeToTree(tpe)
+
+  protected def sealTerm(term: Term, tpt: TypeTree)(implicit ctx: Context): scala.quoted.Expr[_] = {
+    def etaExpand(term: Term): Term = term.tpe.widen match {
+      case mtpe: Types.MethodType if !mtpe.isParamDependent =>
+        val closureResType = mtpe.resType match {
+          case t: Types.MethodType => t.toFunctionType()
+          case t => t
+        }
+        val closureTpe = Types.MethodType(mtpe.paramNames, mtpe.paramInfos, closureResType)
+        val closureMethod = ctx.newSymbol(ctx.owner, nme.ANON_FUN, Synthetic | Method, closureTpe)
+        tpd.Closure(closureMethod, tss => etaExpand(new tpd.TreeOps(term).appliedToArgs(tss.head)))
+      case _ => term
+    }
 
-      val expanded = etaExpand(term)
-      if (expanded.tpe <:< expectedType) {
-        new scala.quoted.Exprs.TastyTreeExpr(expanded).asInstanceOf[scala.quoted.Expr[T]]
-      } else {
-        throw new scala.tasty.TastyTypecheckError(
-          s"""Term: ${term.show}
-             |did not conform to type: ${expectedType.show}
-             |""".stripMargin
-        )
-      }
+    val expectedType = tpt.tpe
+    val expanded = etaExpand(term)
+    if (expanded.tpe <:< expectedType) {
+      new scala.quoted.Exprs.TastyTreeExpr(expanded)
+    } else {
+      throw new scala.tasty.TastyTypecheckError(
+        s"""Term: ${term.show}
+           |did not conform to type: ${expectedType.show}
+           |""".stripMargin
+      )
     }
   }
 

compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala

@@ -352,8 +352,14 @@ class ReifyQuotes extends MacroTransform {
             transformSplice(spliceTree)
 
           case tree: TypeTree if tree.tpe.typeSymbol.isSplice =>
-            val splicedType = tree.tpe.stripTypeVar.asInstanceOf[TypeRef].prefix.termSymbol
-            transformSplice(ref(splicedType).select(tpnme.splice).withSpan(tree.span))
+            tree.tpe.stripTypeVar match {
+              case tp: AppliedType =>
+                val splicedType = tp.tycon.asInstanceOf[TypeRef].prefix.termSymbol
+                AppliedTypeTree(transformSplice(ref(splicedType).select(tpnme.splice)), tp.args.map(TypeTree(_))).withSpan(tree.span)
+              case tp: TypeRef =>
+                val splicedType = tp.prefix.termSymbol
+                transformSplice(ref(splicedType).select(tpnme.splice).withSpan(tree.span))
+            }
 
           case tree: RefTree if isCaptured(tree.symbol, level) =>
             val t = capturers(tree.symbol).apply(tree)

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

@@ -47,7 +47,7 @@ object TestConfiguration {
   val yCheckOptions = Array("-Ycheck:all")
 
   val commonOptions = checkOptions ++ noCheckOptions ++ yCheckOptions
-  val defaultOptions = TestFlags(basicClasspath, commonOptions)
+  val defaultOptions = TestFlags(basicClasspath, commonOptions) and "-Ykind-polymorphism" // FIXME remove "-Ykind-polymorphism"
   val withCompilerOptions =
     defaultOptions.withClasspath(withCompilerClasspath).withRunClasspath(withCompilerClasspath)
   val allowDeepSubtypes = defaultOptions without "-Yno-deep-subtypes"

library/src-bootstrapped/scala/quoted/Type.scala

@@ -0,0 +1,46 @@
+package scala.quoted
+
+import scala.quoted.Types.TaggedType
+import scala.reflect.ClassTag
+import scala.runtime.quoted.Unpickler.Pickled
+
+sealed abstract class Type[T <: AnyKind] {
+  type `$splice` = T
+}
+
+/** Some basic type tags, currently incomplete */
+object Type {
+  /** A term quote is desugared by the compiler into a call to this method */
+  def apply[T <: AnyKind]: Type[T] =
+    throw new Error("Internal error: this method call should have been replaced by the compiler")
+
+  implicit def UnitTag: Type[Unit] = new TaggedType[Unit]
+  implicit def BooleanTag: Type[Boolean] = new TaggedType[Boolean]
+  implicit def ByteTag: Type[Byte] = new TaggedType[Byte]
+  implicit def CharTag: Type[Char] = new TaggedType[Char]
+  implicit def ShortTag: Type[Short] = new TaggedType[Short]
+  implicit def IntTag: Type[Int] = new TaggedType[Int]
+  implicit def LongTag: Type[Long] = new TaggedType[Long]
+  implicit def FloatTag: Type[Float] = new TaggedType[Float]
+  implicit def DoubleTag: Type[Double] = new TaggedType[Double]
+}
+
+/** All implementations of Type[T].
+ *  These should never be used directly.
+ */
+object Types {
+  /** A Type backed by a pickled TASTY tree */
+  final class TastyType[T](val tasty: Pickled, val args: Seq[Any]) extends Type[T] {
+    override def toString(): String = s"Type(<pickled tasty>)"
+  }
+
+  /** An Type backed by a value */
+  final class TaggedType[T](implicit val ct: ClassTag[T]) extends Type[T] {
+    override def toString: String = s"Type($ct)"
+  }
+
+  /** An Type backed by a tree */
+  final class TreeType[Tree](val typeTree: Tree) extends quoted.Type[Any] {
+    override def toString: String = s"Type(<tasty tree>)"
+  }
+}

library/src-bootstrapped/scala/tasty/reflect/QuotedOps.scala

@@ -0,0 +1,32 @@
+package scala.tasty.reflect
+
+/** Extension methods on scala.quoted.{Expr|Type} to convert to scala.tasty.Tasty objects */
+trait QuotedOps extends Core {
+
+  trait QuotedExprAPI {
+    /** View this expression `Expr[T]` as a `Term` */
+    def unseal(implicit ctx: Context): Term
+  }
+  implicit def QuotedExprDeco[T](expr: quoted.Expr[T]): QuotedExprAPI
+
+  implicit class QuotedTypeDeco[T <: AnyKind](tpe: quoted.Type[T]) {
+    /** View this expression `Type[T]` as a `TypeTree` */
+    def unseal(implicit ctx: Context): TypeTree = unsealType(tpe)
+  }
+
+  protected def unsealType(tpe: quoted.Type[_])(implicit ctx: Context): TypeTree
+
+  implicit class TermToQuoteDeco(term: Term) {
+    /** Convert `Term` to an `Expr[T]` and check that it conforms to `T` */
+    def seal[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T] =
+      sealTerm(term, unsealType(implicitly[scala.quoted.Type[T]])).asInstanceOf[scala.quoted.Expr[T]]
+  }
+
+  protected def sealTerm(term: Term, tpt: TypeTree)(implicit ctx: Context): scala.quoted.Expr[_]
+
+  trait TypeToQuotedAPI {
+    /** Convert `Type` to an `quoted.Type[T]` */
+    def seal(implicit ctx: Context): scala.quoted.Type[_]
+  }
+  implicit def TypeToQuoteDeco(tpe: Type): TypeToQuotedAPI
+}

library/src/scala/quoted/Type.scala renamed to library/src-non-bootstrapped/scala/quoted/Type.scala

@@ -13,7 +13,11 @@ trait QuotedOps extends Core {
     /** View this expression `Type[T]` as a `TypeTree` */
     def unseal(implicit ctx: Context): TypeTree
   }
-  implicit def QuotedTypeDeco[T](tpe: quoted.Type[T]): QuotedTypeAPI
+  implicit def QuotedTypeDeco[T](tpe: quoted.Type[T]): QuotedTypeAPI = new QuotedTypeAPI {
+    override def unseal(implicit ctx: Context): TypeTree = unsealType(tpe)
+  }
+
+  protected def unsealType(tpe: quoted.Type[_])(implicit ctx: Context): TypeTree
 
   trait TermToQuotedAPI {
     /** Convert `Term` to an `Expr[T]` and check that it conforms to `T` */

library/src/scala/tasty/reflect/QuotedOps.scala renamed to library/src-non-bootstrapped/scala/tasty/reflect/QuotedOps.scala

@@ -1135,11 +1135,17 @@ object Build {
     def asDottyCompiler(implicit mode: Mode): Project = project.withCommonSettings.
       dependsOn(`dotty-interfaces`).
       dependsOn(dottyLibrary).
-      settings(dottyCompilerSettings)
+      settings(dottyCompilerSettings).
+      bootstrappedSettings(
+        // To support kind polymorphism of scala.quote.Type
+        scalacOptions in Compile += "-Ykind-polymorphism"
+      )
 
     def asDottyLibrary(implicit mode: Mode): Project = project.withCommonSettings.
       settings(dottyLibrarySettings).
       bootstrappedSettings(
+        // To support kind polymorphism of scala.quote.Type
+        scalacOptions in Compile += "-Ykind-polymorphism",
         // Needed so that the library sources are visible when `dotty.tools.dotc.core.Definitions#init` is called.
         scalacOptions in Compile ++= Seq("-sourcepath", (scalaSource in Compile).value.getAbsolutePath)
       )

project/Build.scala

@@ -0,0 +1,15 @@
+{
+  val y: collection.immutable.List[scala.Int] = scala.List.apply[scala.Int](1, 2, 3)
+  (y: collection.immutable.List[evidence$1$_~$1])
+}
+List(1, 2, 3)
+{
+  val y: scala.Option[scala.Int] = scala.Option.apply[scala.Int](4)
+  (y: scala.Option[evidence$1$_~$1])
+}
+Some(4)
+{
+  val y: collection.immutable.Map[scala.Int, scala.Int] = scala.Predef.Map.apply[scala.Int, scala.Int](scala.Predef.ArrowAssoc[scala.Int](4).->[scala.Int](1))
+  (y: collection.immutable.Map[scala.Int, evidence$1$_~$1])
+}
+Map(4 -> 1)

tests/run-with-compiler/i5965.check

@@ -0,0 +1,28 @@
+import scala.quoted._
+
+import scala.tasty._
+
+object Test {
+
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
+
+  def main(args: Array[String]): Unit = {
+    '[List]
+    val list = bound('{List(1, 2, 3)})
+    println(list.show)
+    println(list.run)
+
+    val opt = bound('{Option(4)})
+    println(opt.show)
+    println(opt.run)
+
+    val map = bound('{Map(4 -> 1)})
+    println(map.show)
+    println(map.run)
+  }
+
+  def bound[T: Type, S[_]: Type](x: Expr[S[T]]): Expr[S[T]] = '{
+    val y: S[T] = $x
+    y
+  }
+}