Handle HKTermLambdas in Tasty and TastyImpl

Author: odersky

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

@@ -759,12 +759,14 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
   type LambdaType[ParamInfo <: TypeOrBounds] = Types.LambdaType { type PInfo = ParamInfo }
   type MethodType = Types.MethodType
   type PolyType = Types.PolyType
+  type TermLambda = Types.TermLambda
   type TypeLambda = Types.TypeLambda
 
   def typeClassTag: ClassTag[Type] = implicitly[ClassTag[Type]]
   def recursiveTypeClassTag: ClassTag[RecursiveType] = implicitly[ClassTag[RecursiveType]]
   def methodTypeClassTag: ClassTag[MethodType] = implicitly[ClassTag[MethodType]]
   def polyTypeClassTag: ClassTag[PolyType] = implicitly[ClassTag[PolyType]]
+  def termLambdaClassTag: ClassTag[TermLambda] = implicitly[ClassTag[TermLambda]]
   def typeLambdaClassTag: ClassTag[TypeLambda] = implicitly[ClassTag[TypeLambda]]
 
   def MethodTypeDeco(tpe: MethodType): MethodTypeAPI = new MethodTypeAPI {
@@ -781,6 +783,12 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
     def resultTpe(implicit ctx: Context): Type = tpe.resType
   }
 
+  def TermLambdaDeco(tpe: Types.TermLambda): TermLambdaAPI = new TermLambdaAPI {
+    def paramNames(implicit ctx: Context): List[String] = tpe.paramNames.map(_.toString)
+    def paramTypes(implicit ctx: Context): List[Type] = tpe.paramInfos
+    def resultTpe(implicit ctx: Context): Type = tpe.resType
+  }
+
   def TypeLambdaDeco(tpe: Types.TypeLambda): TypeLambdaAPI = new TypeLambdaAPI {
     def paramNames(implicit ctx: Context): List[String] = tpe.paramNames.map(_.toString)
     def paramTypes(implicit ctx: Context): List[TypeBounds] = tpe.paramInfos
@@ -928,6 +936,13 @@ class TastyImpl(val rootContext: Contexts.Context) extends scala.tasty.Tasty { s
       }
     }
 
+    object TermLambda extends TermLambdaExtractor {
+      def unapply(x: TermLambda)(implicit ctx: Context): Option[(List[String], List[Type], Type)] = x match {
+        case x: TermLambda => Some(x.paramNames.map(_.toString), x.paramInfos, x.resType)
+        case _ => None
+      }
+    }
+
     object TypeLambda extends TypeLambdaExtractor {
       def unapply(x: TypeLambda)(implicit ctx: Context): Option[(List[String], List[TypeBounds], Type)] = x match {
         case x: TypeLambda => Some(x.paramNames.map(_.toString), x.paramInfos, x.resType)

library/src/scala/tasty/Tasty.scala

@@ -593,11 +593,13 @@ abstract class Tasty { tasty =>
   type LambdaType[ParamInfo <: TypeOrBounds] <: Type
   type MethodType <: LambdaType[Type]
   type PolyType <: LambdaType[TypeBounds]
+  type TermLambda <: LambdaType[Type]
   type TypeLambda <: LambdaType[TypeBounds]
 
   implicit def typeClassTag: ClassTag[Type]
   implicit def methodTypeClassTag: ClassTag[MethodType]
   implicit def polyTypeClassTag: ClassTag[PolyType]
+  implicit def termLambdaClassTag: ClassTag[TermLambda]
   implicit def typeLambdaClassTag: ClassTag[TypeLambda]
   implicit def recursiveTypeClassTag: ClassTag[RecursiveType]
 
@@ -617,6 +619,13 @@ abstract class Tasty { tasty =>
   }
   implicit def PolyTypeDeco(tpt: PolyType): PolyTypeAPI
 
+  trait TermLambdaAPI {
+    def paramNames(implicit ctx: Context): List[String]
+    def paramTypes(implicit ctx: Context): List[Type]
+    def resultTpe(implicit ctx: Context): Type
+  }
+  implicit def TermLambdaDeco(tpt: TermLambda): TermLambdaAPI
+
   trait TypeLambdaAPI {
     def paramNames(implicit ctx: Context): List[String]
     def paramTypes(implicit ctx: Context): List[TypeBounds]
@@ -714,6 +723,11 @@ abstract class Tasty { tasty =>
       def unapply(x: PolyType)(implicit ctx: Context): Option[(List[String], List[TypeBounds], Type)]
     }
 
+    val TermLambda: TermLambdaExtractor
+    abstract class TermLambdaExtractor {
+      def unapply(x: TermLambda)(implicit ctx: Context): Option[(List[String], List[Type], Type)]
+    }
+
     val TypeLambda: TypeLambdaExtractor
     abstract class TypeLambdaExtractor {
       def unapply(x: TypeLambda)(implicit ctx: Context): Option[(List[String], List[TypeBounds], Type)]