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

Author: nicolasstucki

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

@@ -14,9 +14,8 @@ 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)
-  }
+  protected def unsealType(tpe: quoted.Type[_])(implicit ctx: Context): TypeTree =
+    PickledQuotes.quotedTypeToTree(tpe)
 
   def TermToQuoteDeco(term: Term): TermToQuotedAPI = new TermToQuotedAPI {
 

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/scala/quoted/Type.scala renamed to library/src-bootstrapped/scala/quoted/Type.scala

@@ -4,14 +4,14 @@ import scala.quoted.Types.TaggedType
 import scala.reflect.ClassTag
 import scala.runtime.quoted.Unpickler.Pickled
 
-sealed abstract class Type[T] {
+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]: Type[T] =
+  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]

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

@@ -0,0 +1,33 @@
+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
+
+  trait QuotedTypeAPI {
+    /** View this expression `Type[T]` as a `TypeTree` */
+    def unseal(implicit ctx: Context): TypeTree
+  }
+  implicit def QuotedTypeDeco[T <: AnyKind](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` */
+    def seal[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T]
+  }
+  implicit def TermToQuoteDeco(term: Term): TermToQuotedAPI
+
+  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-non-bootstrapped/scala/quoted/Type.scala

@@ -0,0 +1,36 @@
+package scala.quoted
+
+import scala.quoted.Types.TaggedType
+import scala.reflect.ClassTag
+import scala.runtime.quoted.Unpickler.Pickled
+
+sealed abstract class Type[T] {
+  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]: Type[T] =
+    throw new Error("Internal error: this method call should have been replaced by the compiler")
+}
+
+/** 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/scala/tasty/reflect/QuotedOps.scala renamed to library/src-non-bootstrapped/scala/tasty/reflect/QuotedOps.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` */

project/Build.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)
       )

tests/run-with-compiler/i5965.check

@@ -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.scala

@@ -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
+  }
+}