Fix #9518: Instantiate HKTypeLambda and replace AppliedType with appliedTo

Author: nicolasstucki

community-build/community-projects/dotty-cps-async

@@ -1224,6 +1224,9 @@ class ReflectionCompilerInterface(val rootContext: Context) extends CompilerInte
   def Type_select(self: Type)(sym: Symbol)(using Context): Type =
     self.select(sym)
 
+  def Type_appliedTo(self: Type)(targs: List[TypeOrBounds]): Type =
+    self.appliedTo(targs)
+
   type ConstantType = Types.ConstantType
 
   def ConstantType_TypeTest(using Context): TypeTest[TypeOrBounds, ConstantType] = new {
@@ -1335,8 +1338,6 @@ class ReflectionCompilerInterface(val rootContext: Context) extends CompilerInte
   def AppliedType_tycon(self: AppliedType)(using Context): Type = self.tycon
   def AppliedType_args(self: AppliedType)(using Context): List[TypeOrBounds] = self.args
 
-  def AppliedType_apply(tycon: Type, args: List[TypeOrBounds])(using Context): AppliedType = Types.AppliedType(tycon, args)
-
   type AnnotatedType = Types.AnnotatedType
 
   def AnnotatedType_TypeTest(using Context): TypeTest[TypeOrBounds, AnnotatedType] = new {

community-build/community-projects/shapeless

@@ -604,6 +604,9 @@ trait CompilerInterface extends scala.tasty.reflect.Types {
   /** The type <this . sym>, reduced if possible */
   def Type_select(self: Type)(sym: Symbol)(using ctx: Context): Type
 
+  /** The current type applied to given type arguments: `this[targ0, ..., targN]` */
+  def Type_appliedTo(self: Type)(targs: List[TypeOrBounds]): Type
+
   def ConstantType_TypeTest(using ctx: Context): TypeTest[TypeOrBounds, ConstantType]
 
   def ConstantType_apply(const : Constant)(using ctx : Context) : ConstantType
@@ -644,8 +647,6 @@ trait CompilerInterface extends scala.tasty.reflect.Types {
   def AppliedType_tycon(self: AppliedType)(using ctx: Context): Type
   def AppliedType_args(self: AppliedType)(using ctx: Context): List[TypeOrBounds]
 
-  def AppliedType_apply(tycon: Type, args: List[TypeOrBounds])(using ctx: Context) : AppliedType
-
   def AnnotatedType_TypeTest(using ctx: Context): TypeTest[TypeOrBounds, AnnotatedType]
 
   def AnnotatedType_apply(underlying: Type, annot: Term)(using ctx: Context): AnnotatedType

compiler/src/dotty/tools/dotc/quoted/reflect/ReflectionCompilerInterface.scala

@@ -1462,6 +1462,13 @@ trait Reflection extends reflect.Types { reflectSelf: CompilerInterface =>
 
       /** The type <this . sym>, reduced if possible */
       def select(sym: Symbol)(using ctx: Context): Type = reflectSelf.Type_select(self)(sym)
+
+      /** The current type applied to given type arguments: `this[targ]` */
+      def appliedTo(targ: TypeOrBounds): Type = reflectSelf.Type_appliedTo(self)(List(targ))
+
+      /** The current type applied to given type arguments: `this[targ0, ..., targN]` */
+      def appliedTo(targs: List[TypeOrBounds]): Type = reflectSelf.Type_appliedTo(self)(targs)
+
     end extension
   end Type
 
@@ -1549,14 +1556,12 @@ trait Reflection extends reflect.Types { reflectSelf: CompilerInterface =>
   given AppliedTypeOps as AppliedType.type = AppliedType
 
   object AppliedType:
-    def apply(tycon: Type, args: List[TypeOrBounds])(using ctx: Context): AppliedType =
-      reflectSelf.AppliedType_apply(tycon, args)
-    def unapply(x: AppliedType)(using ctx: Context): Option[(Type, List[TypeOrBounds /* Type | TypeBounds */])] =
+    def unapply(x: AppliedType)(using ctx: Context): Option[(Type, List[TypeOrBounds])] =
       Some((x.tycon, x.args))
 
     extension (self: AppliedType):
       def tycon(using ctx: Context): Type = reflectSelf.AppliedType_tycon(self)
-      def args(using ctx: Context): List[TypeOrBounds /* Type | TypeBounds */] = reflectSelf.AppliedType_args(self)
+      def args(using ctx: Context): List[TypeOrBounds] = reflectSelf.AppliedType_args(self)
     end extension
   end AppliedType
 

library/src/scala/internal/tasty/CompilerInterface.scala

@@ -28,7 +28,7 @@ object Async {
           case AppliedType(tp,tparams1) =>
             val fType = summon[quoted.Type[F]]
             val ptp = tparams1.tail.head
-            val ptpTree = Inferred(AppliedType(fType.unseal.tpe,List(ptp)))
+            val ptpTree = Inferred(fType.unseal.tpe.appliedTo(ptp))
             '{ println(${Expr(ptpTree.show)}) }
 
 }

library/src/scala/tasty/Reflection.scala

@@ -0,0 +1,21 @@
+
+import scala.quoted._
+
+trait CB[T]
+
+inline def shift : Unit = ${ shiftTerm }
+
+def shiftTerm(using QuoteContext): Expr[Unit] = {
+  import qctx.tasty._
+  val nTree = '{ ??? : CB[Int] }.unseal
+  val tp1 = '[CB[Int]].unseal.tpe
+  val tp2 = '[([X] =>> CB[X])[Int]].unseal.tpe
+  val ta = '[[X] =>> CB[X]]
+  val tp3 = '[ta.T[Int]].unseal.tpe
+  val tp4 = '[CB].unseal.tpe.appliedTo(typeOf[Int])
+  assert(nTree.tpe <:< tp1)
+  assert(nTree.tpe <:< tp2)
+  assert(nTree.tpe <:< tp3)
+  assert(nTree.tpe <:< tp4)
+  '{}
+}

tests/pos-macros/i9251/Macro_1.scala

@@ -0,0 +1 @@
+def test: Unit = shift

tests/pos-macros/i9518/Macro_1.scala

@@ -27,7 +27,7 @@ object Macros {
         typeOf[RefineMe],
         "T",
         TypeBounds(typeOf[Int], typeOf[Int]))
-    val x6T = AppliedType(Type(classOf[List[_]]), List(typeOf[Int]))
+    val x6T = Type(classOf[List[_]]).appliedTo(List(typeOf[Int]))
     val x7T = AnnotatedType(ConstantType(Constant(7)), '{ new TestAnnotation }.unseal)
     val x8T =
       MatchType(
@@ -37,7 +37,7 @@ object Macros {
           TypeLambda(
             List("t"),
             _ => List(TypeBounds(typeOf[Nothing], typeOf[Any])),
-            tl => AppliedType(MatchCaseType, List(AppliedType(Type(classOf[List[_]]), List(tl.param(0))), tl.param(0)))))
+            tl => MatchCaseType.appliedTo(List(Type(classOf[List[_]]).appliedTo(tl.param(0)), tl.param(0)))))
       )
 
     assert(x1T =:= '[1].unseal.tpe)