Covariant-contravariant flag on type args

Author: Tobias Bordenca

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

@@ -94,6 +94,8 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
 
   def TypeSymbolDeco(symbol: TypeSymbol): TypeSymbolAPI = new TypeSymbolAPI {
     def tree(implicit ctx: Context): TypeDef = FromSymbol.typeDefFromSym(symbol)
+
+    def isTypeParam(implicit ctx: Context): Boolean = symbol.isTypeParam
   }
 
   object ClassSymbol extends ClassSymbolModule {

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

@@ -590,8 +590,9 @@ trait Printers
           else if (flags.is(Flags.Abstract)) this += highlightKeyword("abstract class ", color) += highlightTypeDef(name, color)
           else this += highlightKeyword("class ", color) += highlightTypeDef(name, color)
 
+          val typeParams = stats.collect { case IsTypeDef(targ) => targ  }.filter(_.symbol.isTypeParam).zip(targs)
           if (!flags.is(Flags.Object)) {
-            printTargsDefs(targs)
+            printTargsDefs(typeParams)
             val it = argss.iterator
             while (it.hasNext)
               printArgsDefs(it.next())
@@ -606,14 +607,19 @@ trait Printers
           if (parents1.nonEmpty)
             this += highlightKeyword(" extends ", color)
 
-          def printParent(parent: TermOrTypeTree): Unit = parent match {
+          def printParent(parent: TermOrTypeTree, needEmptyParens: Boolean = false): Unit = parent match {
             case IsTypeTree(parent) =>
               printTypeTree(parent)
             case IsTerm(Term.TypeApply(fun, targs)) =>
               printParent(fun)
+            case IsTerm(Term.Apply(fun@Term.Apply(_,_), args)) =>
+              printParent(fun, true)
+              if (!args.isEmpty || needEmptyParens)
+                inParens(printTrees(args, ", "))
             case IsTerm(Term.Apply(fun, args)) =>
               printParent(fun)
-              inParens(printTrees(args, ", "))
+              if (!args.isEmpty || needEmptyParens)
+                inParens(printTrees(args, ", "))
             case IsTerm(Term.Select(Term.New(tpt), _)) =>
               printTypeTree(tpt)
             case IsTerm(parent) =>
@@ -691,7 +697,7 @@ trait Printers
         case IsTypeDef(tdef @ TypeDef(name, rhs)) =>
           printDefAnnotations(tdef)
           this += highlightKeyword("type ", color)
-          printTargDef(tdef, isMember = true)
+          printTargDef((tdef, tdef), isMember = true)
 
         case IsValDef(vdef @ ValDef(name, tpt, rhs)) =>
           printDefAnnotations(vdef)
@@ -754,7 +760,7 @@ trait Printers
           printProtectedOrPrivate(ddef)
 
           this += highlightKeyword("def ", color) += highlightValDef((if (isConstructor) "this" else name), color)
-          printTargsDefs(targs)
+          printTargsDefs(targs.zip(targs))
           val it = argss.iterator
           while (it.hasNext)
             printArgsDefs(it.next())
@@ -1125,13 +1131,13 @@ trait Printers
         this
       }
 
-      def printTargsDefs(targs: List[TypeDef]): Unit = {
+      def printTargsDefs(targs: List[(TypeDef, TypeDef)], isDef:Boolean = true): Unit = {
         if (!targs.isEmpty) {
-          def printSeparated(list: List[TypeDef]): Unit = list match {
+          def printSeparated(list: List[(TypeDef, TypeDef)]): Unit = list match {
             case Nil =>
-            case x :: Nil => printTargDef(x)
+            case x :: Nil => printTargDef(x, isDef = isDef)
             case x :: xs =>
-              printTargDef(x)
+              printTargDef(x, isDef = isDef)
               this += ", "
               printSeparated(xs)
           }
@@ -1140,9 +1146,19 @@ trait Printers
         }
       }
 
-      def printTargDef(arg: TypeDef, isMember: Boolean = false): Buffer = {
-        this += arg.name
-        arg.rhs match {
+      def printTargDef(arg: (TypeDef, TypeDef), isMember: Boolean = false, isDef:Boolean = true): Buffer = {
+        val (argDef, argCons) = arg
+
+        if (isDef) {
+          if (argDef.symbol.flags.is(Flags.Covariant)) {
+            this += highlightValDef("+", color)
+          } else if (argDef.symbol.flags.is(Flags.Contravariant)) {
+            this += highlightValDef("-", color)
+          }
+        }
+
+        this += argCons.name
+        argCons.rhs match {
           case IsTypeBoundsTree(rhs) => printBoundsTree(rhs)
           case rhs @ WildcardTypeTree() =>
             printTypeOrBound(rhs.tpe)
@@ -1412,7 +1428,7 @@ trait Printers
           printTypeTree(result)
 
         case TypeTree.LambdaTypeTree(tparams, body) =>
-          printTargsDefs(tparams)
+          printTargsDefs(tparams.zip(tparams), isDef = false)
           this += highlightTypeDef(" => ", color)
           printTypeOrBoundsTree(body)
 

library/src/scala/tasty/reflect/SymbolOps.scala

@@ -123,6 +123,8 @@ trait SymbolOps extends Core {
   trait TypeSymbolAPI {
     /** TypeDef tree of this defintion. */
     def tree(implicit ctx: Context): TypeDef
+
+    def isTypeParam(implicit ctx: Context): Boolean
   }
   implicit def TypeSymbolDeco(symbol: TypeSymbol): TypeSymbolAPI