Tasty pickling of variances in TypeBounds

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -3486,10 +3486,16 @@ object Types {
     }
 
     override def newLikeThis(paramNames: List[ThisName], paramInfos: List[PInfo], resType: Type)(implicit ctx: Context): This =
-      HKTypeLambda(paramNames, givenVariances)(
+      newLikeThis(paramNames, givenVariances, paramInfos, resType)
+
+    def newLikeThis(paramNames: List[ThisName], variances: List[Variance], paramInfos: List[PInfo], resType: Type)(implicit ctx: Context): This =
+      HKTypeLambda(paramNames, variances)(
           x => paramInfos.mapConserve(_.subst(this, x).asInstanceOf[PInfo]),
           x => resType.subst(this, x))
 
+    def withVariances(variances: List[Variance])(implicit ctx: Context): This =
+      newLikeThis(paramNames, variances, paramInfos, resType)
+
     protected def prefixString: String = "HKTypeLambda"
     final override def toString: String =
       if isVariant then

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -134,6 +134,15 @@ class TreePickler(pickler: TastyPickler) {
       pickleType(c.symbolValue.termRef)
   }
 
+  def pickleVariances(tp: Type)(given Context): Unit = tp match
+    case tp: HKTypeLambda if tp.isVariant =>
+      for v <- tp.givenVariances do
+        writeByte(
+          if v.is(Covariant) then COVARIANT
+          else if v.is(Contravariant) then CONTRAVARIANT
+          else STABLE)
+    case _ =>
+
   def pickleType(tpe0: Type, richTypes: Boolean = false)(implicit ctx: Context): Unit = {
     val tpe = tpe0.stripTypeVar
     try {
@@ -230,11 +239,23 @@ class TreePickler(pickler: TastyPickler) {
       writeByte(RECtype)
       pickleType(tpe.parent)
     case tpe: TypeAlias =>
-      writeByte(TYPEALIAS)
-      pickleType(tpe.alias, richTypes)
+      tpe.alias match
+        case alias: HKTypeLambda if alias.isVariant =>
+          writeByte(TYPEBOUNDS)
+          withLength {
+            pickleType(tpe.alias, richTypes)
+            pickleVariances(tpe.alias)
+          }
+        case _ =>
+          writeByte(TYPEALIAS)
+          pickleType(tpe.alias, richTypes)
     case tpe: TypeBounds =>
       writeByte(TYPEBOUNDS)
-      withLength { pickleType(tpe.lo, richTypes); pickleType(tpe.hi, richTypes) }
+      withLength {
+        pickleType(tpe.lo, richTypes)
+        pickleType(tpe.hi, richTypes)
+        pickleVariances(tpe.hi)
+      }
     case tpe: AnnotatedType =>
       writeByte(ANNOTATEDtype)
       withLength { pickleType(tpe.parent, richTypes); pickleTree(tpe.annot.tree) }

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -16,6 +16,7 @@ import Flags._
 import Constants._
 import Annotations._
 import NameKinds._
+import Variances.Invariant
 import typer.ConstFold
 import typer.Checking.checkNonCyclic
 import util.Spans._
@@ -303,6 +304,17 @@ class TreeUnpickler(reader: TastyReader,
           result.asInstanceOf[LT]
         }
 
+        def readVariances(tp: Type): Type = tp match
+          case tp: HKTypeLambda if currentAddr != end =>
+            val vs = until(end) {
+              readByte() match
+                case STABLE => Invariant
+                case COVARIANT => Covariant
+                case CONTRAVARIANT => Contravariant
+            }
+            tp.withVariances(vs)
+          case _ => tp
+
         val result =
           (tag: @switch) match {
             case TERMREFin =>
@@ -335,9 +347,10 @@ class TreeUnpickler(reader: TastyReader,
               readType().appliedTo(until(end)(readType()))
             case TYPEBOUNDS =>
               val lo = readType()
-              val hi = readType()
-              if (lo.isMatch && (lo `eq` hi)) MatchAlias(lo)
-              else TypeBounds(lo, hi)
+              val hi = if nothingButMods(end) then lo else readType()
+              val variantHi = readVariances(hi)
+              if (lo.isMatch && (lo `eq` hi)) MatchAlias(variantHi)
+              else TypeBounds(lo, variantHi)
             case ANNOTATEDtype =>
               AnnotatedType(readType(), Annotation(readTerm()))
             case ANDtype =>

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -154,7 +154,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   REFINEDtype    Length underlying_Type refinement_NameRef info_Type -- underlying { refinement_name : info }
                   APPLIEDtype    Length tycon_Type arg_Type*                       -- tycon[args]
                   TYPEALIAS             alias_Type                                 -- = alias
-                  TYPEBOUNDS     Length low_Type high_Type                         -- >: low <: high
+                  TYPEBOUNDS     Length lowOrAlias_Type high_Type? Variance*       -- = alias or >: low <: high, possibly with variances of lambda parameters
                   ANNOTATEDtype  Length underlying_Type annotation_Term            -- underlying @ annotation
                   ANDtype        Length left_Type right_Type                       -- left & right
                   ORtype         Length left_Type right_Type                       -- lefgt | right
@@ -213,6 +213,10 @@ Standard-Section: "ASTs" TopLevelStat*
                   OPEN                                                             -- an open class
                   Annotation
 
+  Variance      = SEALED                                                           -- invariant
+                | COVARIANT
+                | CONTRAVARIANT
+
   Annotation    = ANNOTATION     Length tycon_Type fullAnnotation_Term             -- An annotation, given (class) type of constructor, and full application tree
 
 Note: Tree tags are grouped into 5 categories that determine what follows, and thus allow to compute the size of the tagged tree in a generic way.