Fix #5404: Add MatchType to TASTy reflect

Author: nicolasstucki

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

@@ -13,4 +13,12 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with TastyCoreImpl w
     def unapply(x: CaseDef): Some[(Pattern, Option[Term], Term)] = Some(x.pat, optional(x.guard), x.body)
   }
 
+  def TypeCaseDefDeco(caseDef: TypeCaseDef): TypeCaseDefAPI = new TypeCaseDefAPI {
+    def pattern(implicit ctx: Context): Pattern = caseDef.pat
+    def rhs(implicit ctx: Context): Term = caseDef.body
+  }
+
+  object TypeCaseDef extends TypeCaseDefExtractor {
+    def unapply(x: TypeCaseDef): Some[(TypeTree, TypeTree)] = Some((x.pat, x.body))
+  }
 }

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

@@ -26,6 +26,7 @@ trait TastyCoreImpl extends scala.tasty.reflect.TastyCore {
       type Term = tpd.Tree
 
   type CaseDef = tpd.CaseDef
+  type TypeCaseDef = tpd.CaseDef
 
   type Pattern = tpd.Tree
     type Value = tpd.Tree

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

@@ -123,6 +123,13 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with Tasty
       }
     }
 
+    object MatchType extends MatchTypeExtractor {
+      def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type, List[Type])] = x match {
+        case Types.MatchType(bound, scrutinee, cases) => Some((bound, scrutinee, cases))
+        case _ => None
+      }
+    }
+
     object ByNameType extends ByNameTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[Type] = x match {
         case Types.ExprType(resType) => Some(resType.stripTypeVar)

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

@@ -100,6 +100,13 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
       }
     }
 
+    object MatchType extends MatchTypeExtractor {
+      def unapply(x: TypeOrBoundsTree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[CaseDef])] = x match {
+        case x: tpd.MatchTypeTree => Some((if (x.bound == tpd.EmptyTree) None else Some(x.bound), x.selector, x.cases))
+        case _ => None
+      }
+    }
+
     object ByName extends ByNameExtractor {
       def unapply(x: TypeTree)(implicit ctx: Context): Option[TypeTree] = x match {
         case x: tpd.ByNameTypeTree => Some(x.result)

compiler/test/dotc/pos-from-tasty.blacklist

@@ -16,9 +16,6 @@ repeatedArgs213.scala
 # Error printing parent constructors that are blocks
 default-super.scala
 
-# Need to implement printing of match types
-matchtype.scala
-
 # Did not survive addition of type ascriptions in decompiled tests
 i3050.scala
 i4006b.scala

compiler/test/dotc/pos-recompilation.whitelist

@@ -376,7 +376,6 @@ lookupswitch
 macro-deprecate-dont-touch-backquotedidents
 Map
 match
-matchtype
 matthias3
 matthias4
 matthias5

library/src/scala/tasty/reflect/CaseDefOps.scala

@@ -16,4 +16,15 @@ trait CaseDefOps extends TastyCore {
     def unapply(x: CaseDef): Option[(Pattern, Option[Term], Term)]
   }
 
+
+  trait TypeCaseDefAPI {
+    def pattern(implicit ctx: Context): TypeTree
+    def rhs(implicit ctx: Context): TypeTree
+  }
+  implicit def TypeCaseDefDeco(caseDef: TypeCaseDef): TypeCaseDefAPI
+
+  val TypeCaseDef: TypeCaseDefExtractor
+  abstract class TypeCaseDefExtractor {
+    def unapply(x: TypeCaseDef): Option[(TypeTree, TypeTree)]
+  }
 }

library/src/scala/tasty/reflect/TastyCore.scala

@@ -46,6 +46,7 @@ package scala.tasty.reflect
  *                         |               +- Annotated
  *                         |               +- And
  *                         |               +- Or
+ *                         |               +- MatchType
  *                         |               +- ByName
  *                         |               +- TypeLambdaTree
  *                         |               +- Bind
@@ -54,6 +55,7 @@ package scala.tasty.reflect
  *                         +- SyntheticBounds
  *
  *  +- CaseDef
+ *  +- TypeCaseDef
  *
  *  +- Pattern --+- Value
  *               +- Bind
@@ -75,6 +77,7 @@ package scala.tasty.reflect
  *                                  +- AnnotatedType
  *                                  +- AndType
  *                                  +- OrType
+ *                                  +- MatchType
  *                                  +- ByNameType
  *                                  +- ParamRef
  *                                  +- ThisType
@@ -137,6 +140,9 @@ trait TastyCore {
   /** Branch of a pattern match or catch clause */
   type CaseDef
 
+  /** Branch of a type pattern match */
+  type TypeCaseDef
+
   /** Pattern tree of the pattern part of a CaseDef */
   type Pattern
     type Value <: Pattern

library/src/scala/tasty/reflect/TypeOrBoundsOps.scala

@@ -92,6 +92,11 @@ trait TypeOrBoundsOps extends TastyCore {
       def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)]
     }
 
+    val MatchType: MatchTypeExtractor
+    abstract class MatchTypeExtractor {
+      def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type, List[Type])]
+    }
+
     val ByNameType: ByNameTypeExtractor
     abstract class ByNameTypeExtractor {
       def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[Type]

library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala

@@ -77,6 +77,11 @@ trait TypeOrBoundsTreeOps extends TastyCore {
       def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(TypeTree, TypeTree)]
     }
 
+    val MatchType: MatchTypeExtractor
+    abstract class MatchTypeExtractor {
+      def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[TypeCaseDef])]
+    }
+
     val ByName: ByNameExtractor
     abstract class ByNameExtractor {
       def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[TypeTree]

library/src/scala/tasty/util/ShowExtractors.scala

@@ -125,13 +125,20 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "TypeBoundsTree(" += lo += ", " += hi += ")"
       case SyntheticBounds() =>
         this += s"SyntheticBounds()"
+      case TypeTree.MatchType(bound, selector, cases) =>
+        this += "TypeTree.MatchType(" += bound += ", " += selector += ", " ++= cases += ")"
     }
 
     def visitCaseDef(x: CaseDef): Buffer = {
       val CaseDef(pat, guard, body) = x
       this += "CaseDef(" += pat += ", " += guard += ", " += body += ")"
     }
 
+    def visitTypeCaseDef(x: TypeCaseDef): Buffer = {
+      val TypeCaseDef(pat, body) = x
+      this += "TypeCaseDef(" += pat += ", " += body += ")"
+    }
+
     def visitPattern(x: Pattern): Buffer = x match {
       case Pattern.Value(v) =>
         this += "Pattern.Value(" += v += ")"
@@ -185,6 +192,8 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "Type.AndType(" += left += ", " += right += ")"
       case Type.OrType(left, right) =>
         this += "Type.OrType(" += left += ", " += right += ")"
+      case Type.MatchType(bound, scrutinee, cases) =>
+        this += "Type.MatchType(" += bound += ", " += scrutinee += ", " ++= cases += ")"
       case Type.ByNameType(underlying) =>
         this += "Type.ByNameType(" += underlying += ")"
       case Type.ParamRef(binder, idx) =>
@@ -259,6 +268,11 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       def ++=(x: List[CaseDef]): Buffer = { visitList(x, visitCaseDef); buff }
     }
 
+    private implicit class TypeCaseDefOps(buff: Buffer) {
+      def +=(x: TypeCaseDef): Buffer = { visitTypeCaseDef(x); buff }
+      def ++=(x: List[TypeCaseDef]): Buffer = { visitList(x, visitTypeCaseDef); buff }
+    }
+
     private implicit class PatternOps(buff: Buffer) {
       def +=(x: Pattern): Buffer = { visitPattern(x); buff }
       def ++=(x: List[Pattern]): Buffer = { visitList(x, visitPattern); buff }

library/src/scala/tasty/util/ShowSourceCode.scala

@@ -487,6 +487,19 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       this
     }
 
+    def printTypes(trees: List[Type], sep: String): Buffer = {
+      def printSeparated(list: List[Type]): Unit = list match {
+        case Nil =>
+        case x :: Nil => printType(x)
+        case x :: xs =>
+          printType(x)
+          this += sep
+          printSeparated(xs)
+      }
+      printSeparated(trees)
+      this
+    }
+
     def printImportSelectors(selectors: List[ImportSelector]): Buffer = {
       def printSeparated(list: List[ImportSelector]): Unit = list match {
         case Nil =>
@@ -514,6 +527,19 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       this
     }
 
+    def printTypeCases(cases: List[TypeCaseDef], sep: String): Buffer = {
+      def printSeparated(list: List[TypeCaseDef]): Unit = list match {
+        case Nil =>
+        case x :: Nil => printTypeCaseDef(x)
+        case x :: xs =>
+          printTypeCaseDef(x)
+          this += sep
+          printSeparated(xs)
+      }
+      printSeparated(cases)
+      this
+    }
+
     def printPatterns(cases: List[Pattern], sep: String): Buffer = {
       def printSeparated(list: List[Pattern]): Unit = list match {
         case Nil =>
@@ -592,6 +618,12 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
           }
           inSquare(printSeparated(tparams))
           if (isMember) {
+            body match {
+              case TypeTree.MatchType(Some(bound), _, _) =>
+                this +=  " <: "
+                printTypeTree(bound)
+              case _ =>
+            }
             this += " = "
             printTypeOrBoundsTree(body)
           }
@@ -683,6 +715,14 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       this
     }
 
+    def printTypeCaseDef(caseDef: TypeCaseDef): Buffer = {
+      this += highlightValDef("case ", color)
+      printTypeTree(caseDef.pattern)
+      this += highlightValDef(" => ", color)
+      printTypeTree(caseDef.rhs)
+      this
+    }
+
     def printPattern(pattern: Pattern): Buffer = pattern match {
       case Pattern.Value(v) =>
         v match {
@@ -817,6 +857,11 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += highlightTypeDef(" | ", color)
         printTypeTree(right)
 
+      case TypeTree.MatchType(bound, selector, cases) =>
+        printTypeTree(selector)
+        this += highlightKeyword(" match ", color)
+        inBlock(printTypeCases(cases, lineBreak()))
+
       case TypeTree.ByName(result) =>
         this += highlightTypeDef("=> ", color)
         printTypeTree(result)
@@ -916,6 +961,11 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += highlightTypeDef(" | ", color)
         printType(right)
 
+      case Type.MatchType(bound, scrutinee, cases) =>
+        printType(scrutinee)
+        this += highlightKeyword(" match ", color)
+        inBlock(printTypes(cases, lineBreak()))
+
       case Type.ByNameType(tp) =>
         this += highlightTypeDef(" => ", color)
         printType(tp)