Make TASTy reflect CaseDef <: Tree and TypeCaseDef <: Tree

Author: nicolasstucki

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

@@ -820,12 +820,13 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   def WildcardTypeTree_tpe(self: WildcardTypeTree)(implicit ctx: Context): TypeOrBounds = self.tpe.stripTypeVar
 
-  //
-  // CASES
-  //
-
   type CaseDef = tpd.CaseDef
 
+  def matchCaseDef(tree: Tree)(implicit ctx: Context): Option[CaseDef] = tree match {
+    case tree: tpd.CaseDef if tree.body.isTerm => Some(tree)
+    case _ => None
+  }
+
   def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern = self.pat
   def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term] = optional(self.guard)
   def CaseDef_rhs(self: CaseDef)(implicit ctx: Context): Term = self.body
@@ -838,6 +839,11 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   type TypeCaseDef = tpd.CaseDef
 
+  def matchTypeCaseDef(tree: Tree)(implicit ctx: Context): Option[TypeCaseDef] = tree match {
+    case tree: tpd.CaseDef if tree.body.isType => Some(tree)
+    case _ => None
+  }
+
   def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree = self.pat
   def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree = self.body
 

docs/docs/reference/other-new-features/tasty-reflect.md

@@ -130,9 +130,8 @@ TASTy Reflect provides the following types:
          |
          +- TypeBoundsTree
          +- SyntheticBounds
-
-+- CaseDef
-+- TypeCaseDef
+         +- CaseDef
+         +- TypeCaseDef
 
 +- Pattern --+- Value
              +- Bind

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

@@ -10,31 +10,41 @@ trait CaseDefOps extends Core {
     def rhs(implicit ctx: Context): Term = kernel.CaseDef_rhs(caseDef)
   }
 
+  object IsCaseDef {
+    def unapply(self: Tree)(implicit ctx: Context): Option[CaseDef] =
+      kernel.matchCaseDef(self)
+  }
+
   object CaseDef {
     def apply(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef =
       kernel.CaseDef_module_apply(pattern, guard, rhs)
 
     def copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef =
       kernel.CaseDef_module_copy(original)(pattern, guard, rhs)
 
-    def unapply(x: CaseDef)(implicit ctx: Context): Option[(Pattern, Option[Term], Term)] =
-      Some((x.pattern, x.guard, x.rhs))
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(Pattern, Option[Term], Term)] =
+      kernel.matchCaseDef(tree).map( x => (x.pattern, x.guard, x.rhs))
   }
 
   implicit class TypeCaseDefAPI(caseDef: TypeCaseDef) {
     def pattern(implicit ctx: Context): TypeTree = kernel.TypeCaseDef_pattern(caseDef)
     def rhs(implicit ctx: Context): TypeTree = kernel.TypeCaseDef_rhs(caseDef)
   }
 
+  object TypeIsCaseDef {
+    def unapply(self: Tree)(implicit ctx: Context): Option[TypeCaseDef] =
+      kernel.matchTypeCaseDef(self)
+  }
+
   object TypeCaseDef {
     def apply(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef =
       kernel.TypeCaseDef_module_apply(pattern, rhs)
 
     def copy(original: TypeCaseDef)(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef =
       kernel.TypeCaseDef_module_copy(original)(pattern, rhs)
 
-    def unapply(x: TypeCaseDef)(implicit ctx: Context): Option[(TypeTree, TypeTree)] =
-      Some((x.pattern, x.rhs))
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)] =
+      kernel.matchTypeCaseDef(tree).map( x => (x.pattern, x.rhs))
   }
 
 }

library/src/scala/tasty/reflect/Core.scala

@@ -53,9 +53,8 @@ package scala.tasty.reflect
  *           |
  *           +- TypeBoundsTree
  *           +- WildcardTypeTree
- *
- *  +- CaseDef
- *  +- TypeCaseDef
+ *           +- CaseDef
+ *           +- TypeCaseDef
  *
  *  +- Pattern --+- Value
  *               +- Bind

library/src/scala/tasty/reflect/Kernel.scala

@@ -52,9 +52,8 @@ package scala.tasty.reflect
  *           |
  *           +- TypeBoundsTree
  *           +- WildcardTypeTree
- *
- *  +- CaseDef
- *  +- TypeCaseDef
+ *           +- CaseDef
+ *           +- TypeCaseDef
  *
  *  +- Pattern --+- Value
  *               +- Bind
@@ -670,12 +669,10 @@ trait Kernel {
 
   def WildcardTypeTree_tpe(self: WildcardTypeTree)(implicit ctx: Context): TypeOrBounds
 
-  //
-  // CASES
-  //
-  
   /** Branch of a pattern match or catch clause */
-  type CaseDef <: AnyRef
+  type CaseDef <: Tree
+
+  def matchCaseDef(tree: Tree)(implicit ctx: Context): Option[CaseDef]
 
   def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern
   def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term]
@@ -685,7 +682,9 @@ trait Kernel {
   def CaseDef_module_copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef
 
   /** Branch of a type pattern match */
-  type TypeCaseDef <: AnyRef
+  type TypeCaseDef <: Tree
+
+  def matchTypeCaseDef(tree: Tree)(implicit ctx: Context): Option[TypeCaseDef]
 
   def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree
   def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree

library/src/scala/tasty/reflect/Printers.scala

@@ -38,14 +38,6 @@ trait Printers
     def showCode(implicit ctx: Context): String = new SourceCodePrinter().showTypeOrBounds(tpe)
   }
 
-  /** Adds `show` as an extension method of a `CaseDef` */
-  implicit class CaseDefShowDeco(caseDef: CaseDef) {
-    /** Shows the tree as extractors */
-    def show(implicit ctx: Context): String = new ExtractorsPrinter().showCaseDef(caseDef)
-    /** Shows the tree as source code */
-    def showCode(implicit ctx: Context): String = new SourceCodePrinter().showCaseDef(caseDef)
-  }
-
   /** Adds `show` as an extension method of a `Pattern` */
   implicit class PatternShowDeco(pattern: Pattern) {
     /** Shows the tree as extractors */
@@ -82,8 +74,6 @@ trait Printers
 
     def showTree(tree: Tree)(implicit ctx: Context): String
 
-    def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String
-
     def showPattern(pattern: Pattern)(implicit ctx: Context): String
 
     def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String
@@ -101,9 +91,6 @@ trait Printers
     def showTree(tree: Tree)(implicit ctx: Context): String =
       new Buffer().visitTree(tree).result()
 
-    def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String =
-      new Buffer().visitCaseDef(caseDef).result()
-
     def showPattern(pattern: Pattern)(implicit ctx: Context): String =
       new Buffer().visitPattern(pattern).result()
 
@@ -251,16 +238,10 @@ trait Printers
           this += s"WildcardTypeTree()"
         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 += ")"
+        case CaseDef(pat, guard, body) =>
+          this += "CaseDef(" += pat += ", " += guard += ", " += body += ")"
+        case TypeCaseDef(pat, body) =>
+          this += "TypeCaseDef(" += pat += ", " += body += ")"
       }
 
       def visitPattern(x: Pattern): Buffer = x match {
@@ -382,16 +363,6 @@ trait Printers
         def +++=(x: List[List[Tree]]): Buffer = { visitList(x, ++=); buff }
       }
 
-      private implicit class CaseDefOps(buff: Buffer) {
-        def +=(x: CaseDef): Buffer = { visitCaseDef(x); buff }
-        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 }
@@ -459,9 +430,6 @@ trait Printers
     def showTree(tree: Tree)(implicit ctx: Context): String =
       (new Buffer).printTree(tree).result()
 
-    def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String =
-      (new Buffer).printCaseDef(caseDef).result()
-
     def showPattern(pattern: Pattern)(implicit ctx: Context): String =
       (new Buffer).printPattern(pattern).result()
 

tests/run/tasty-custom-show/quoted_1.scala

@@ -42,7 +42,6 @@ object Macros {
     import reflect._
     new Printer {
       def showTree(tree: Tree)(implicit ctx: Context): String = "Tree"
-      def showCaseDef(caseDef: CaseDef)(implicit ctx: Context): String = "CaseDef"
       def showPattern(pattern: Pattern)(implicit ctx: Context): String = "Pattern"
       def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String = "TypeOrBounds"
       def showConstant(const: Constant)(implicit ctx: Context): String = "Constant"