Add derived field to Tasty reflect

Author: odersky

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

@@ -32,6 +32,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     private def rhs = cdef.rhs.asInstanceOf[tpd.Template]
     def constructor(implicit ctx: Context): DefDef = rhs.constr
     def parents(implicit ctx: Context): List[TermOrTypeTree] = rhs.parents
+    def derived(implicit ctx: Context): List[TypeTree] = rhs.derived.asInstanceOf[List[TypeTree]]
     def self(implicit ctx: Context): Option[tpd.ValDef] = optional(rhs.self)
     def body(implicit ctx: Context): List[Statement] = rhs.body
     def symbol(implicit ctx: Context): ClassSymbol = cdef.symbol.asClass
@@ -250,14 +251,14 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
 
   object ClassDef extends ClassDefModule {
 
-    def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = {
+    def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef = {
       val Trees.TypeDef(_, originalImpl: tpd.Template) = original
-      tpd.cpy.TypeDef(original)(name.toTypeName, tpd.cpy.Template(originalImpl)(constr, parents, selfOpt.getOrElse(tpd.EmptyValDef), body))
+      tpd.cpy.TypeDef(original)(name.toTypeName, tpd.cpy.Template(originalImpl)(constr, parents, derived, selfOpt.getOrElse(tpd.EmptyValDef), body))
     }
 
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[TermOrTypeTree],  Option[ValDef], List[Statement])] = tree match {
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[TermOrTypeTree], List[TypeTree], Option[ValDef], List[Statement])] = tree match {
       case Trees.TypeDef(name, impl: tpd.Template) =>
-        Some((name.toString, impl.constr, impl.parents, optional(impl.self), impl.body))
+        Some((name.toString, impl.constr, impl.parents, impl.derived.asInstanceOf[List[TypeTree]], optional(impl.self), impl.body))
       case _ => None
     }
   }

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

@@ -186,9 +186,10 @@ trait Printers
           this += "DefDef(\"" += name += "\", " ++= typeParams += ", " +++= paramss += ", " += returnTpt += ", " += rhs += ")"
         case TypeDef(name, rhs) =>
           this += "TypeDef(\"" += name += "\", " += rhs += ")"
-        case ClassDef(name, constr, parents, self, body) =>
+        case ClassDef(name, constr, parents, derived, self, body) =>
           this += "ClassDef(\"" += name += "\", " += constr += ", "
           visitList[TermOrTypeTree](parents, visitTermOrTypeTree)
+          visitList[TypeTree](derived, visitTypeTree)
           this += ", " += self += ", " ++= body += ")"
         case PackageDef(name, owner) =>
           this += "PackageDef(\"" += name += "\", " += owner += ")"
@@ -569,7 +570,7 @@ trait Printers
           this += "."
           printImportSelectors(selectors)
 
-        case IsClassDef(cdef @ ClassDef(name, DefDef(_, targs, argss, _, _), parents, self, stats)) =>
+        case IsClassDef(cdef @ ClassDef(name, DefDef(_, targs, argss, _, _), parents, derived, self, stats)) =>
           printDefAnnotations(cdef)
 
           val flags = cdef.symbol.flags
@@ -625,6 +626,11 @@ trait Printers
           }
           printSeparated(parents1)
 
+          if (derived.nonEmpty) {
+            this += highlightKeyword(" derives ", color)
+            printTypeTrees(derived, ", ")
+          }
+
           def keepDefinition(d: Definition): Boolean = {
             val flags = d.symbol.flags
             def isCaseClassUnOverridableMethod: Boolean = {
@@ -1004,19 +1010,25 @@ trait Printers
         printSeparated(stats)
       }
 
-      def printTrees(trees: List[Tree], sep: String): Buffer = {
-        def printSeparated(list: List[Tree]): Unit = list match {
+      def printList[T](xs: List[T], sep: String, print: T => Buffer): Buffer = {
+        def printSeparated(list: List[T]): Unit = list match {
           case Nil =>
-          case x :: Nil => printTree(x)
+          case x :: Nil => print(x)
           case x :: xs =>
-            printTree(x)
+            print(x)
             this += sep
             printSeparated(xs)
         }
-        printSeparated(trees)
+        printSeparated(xs)
         this
       }
 
+      def printTrees(trees: List[Tree], sep: String): Buffer =
+        printList(trees, sep, printTree)
+
+      def printTypeTrees(trees: List[TypeTree], sep: String): Buffer =
+        printList(trees, sep, printTypeTree)
+
       def printTypes(trees: List[Type], sep: String): Buffer = {
         def printSeparated(list: List[Type]): Unit = list match {
           case Nil =>
@@ -1201,7 +1213,7 @@ trait Printers
         val name = arg.name
         arg.symbol.owner match {
           case IsDefSymbol(sym) if sym.name == "<init>" =>
-            val ClassDef(_, _, _, _, body) = sym.owner.asClass.tree
+            val ClassDef(_, _, _, _, _, body) = sym.owner.asClass.tree
             body.collectFirst {
               case IsValDef(vdef @ ValDef(`name`, _, _)) if vdef.symbol.flags.is(Flags.ParamAccessor) =>
                 if (!vdef.symbol.flags.is(Flags.Local)) {
@@ -1552,7 +1564,7 @@ trait Printers
       def printDefinitionName(sym: Definition): Buffer = sym match {
         case ValDef(name, _, _) => this += highlightValDef(name, color)
         case DefDef(name, _, _, _, _) => this += highlightValDef(name, color)
-        case ClassDef(name, _, _, _, _) => this += highlightTypeDef(name.stripSuffix("$"), color)
+        case ClassDef(name, _, _, _, _, _) => this += highlightTypeDef(name.stripSuffix("$"), color)
         case TypeDef(name, _) => this += highlightTypeDef(name, color)
         case PackageDef(name, _) => this += highlightTypeDef(name, color)
       }

library/src/scala/tasty/reflect/TreeOps.scala

@@ -109,13 +109,14 @@ trait TreeOps extends Core {
   val ClassDef: ClassDefModule
   abstract class ClassDefModule {
     // TODO def apply(name: String, constr: DefDef, parents: List[TermOrTypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef
-    def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef
-    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[TermOrTypeTree], Option[ValDef], List[Statement])]
+    def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[TermOrTypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef
+    def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[TermOrTypeTree], List[TypeTree], Option[ValDef], List[Statement])]
   }
 
   trait ClassDefAPI {
     def constructor(implicit ctx: Context): DefDef
     def parents(implicit ctx: Context): List[TermOrTypeTree]
+    def derived(implicit ctx: Context): List[TypeTree]
     def self(implicit ctx: Context): Option[ValDef]
     def body(implicit ctx: Context): List[Statement]
 

library/src/scala/tasty/reflect/TreeUtils.scala

@@ -77,9 +77,9 @@ trait TreeUtils
         case IsDefinition(tdef @ TypeDef(_, rhs)) =>
           implicit val ctx = localCtx(tdef)
           foldTypeTree(x, rhs)
-        case IsDefinition(cdef @ ClassDef(_, constr, parents, self, body)) =>
+        case IsDefinition(cdef @ ClassDef(_, constr, parents, derived, self, body)) =>
           implicit val ctx = localCtx(cdef)
-          foldTrees(foldTrees(foldParents(foldTree(x, constr), parents), self), body)
+          foldTrees(foldTrees(foldTypeTrees(foldParents(foldTree(x, constr), parents), derived), self), body)
         case Import(expr, selectors) =>
           foldTree(x, expr)
         case IsPackageClause(clause @ PackageClause(pid, stats)) =>
@@ -183,7 +183,7 @@ trait TreeUtils
           implicit val ctx = localCtx(tree)
           TypeDef.copy(tree)(tree.name, transformTypeOrBoundsTree(tree.rhs))
         case IsClassDef(tree) =>
-          ClassDef.copy(tree)(tree.name, tree.constructor, tree.parents, tree.self, tree.body)
+          ClassDef.copy(tree)(tree.name, tree.constructor, tree.parents, tree.derived, tree.self, tree.body)
         case IsImport(tree) =>
           Import.copy(tree)(transformTerm(tree.expr), tree.selectors)
       }