Rework variances of higher-kinded types

Decouple variances from type lambdas. A type lambda is just
a function from types to types, it does not have a declared
parameter variance. Of course, the variance of a type parameter
can be determined by tracking occurrences of the parameter
on the right hand side. That's a structural criterion, not
a user-defined one.

Intead of storing variances in type lambdas, store them in
TypeBounds types. A non-alias type bound can have a declared
parameter variance.

The hope is that this change clarifies things conceptually
and addresses tricky type inference problems that involve
type aliases.

First commit: Change TypeBounds data structures so that they can
contain type parameter variances.

Author: odersky

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

@@ -4251,6 +4251,14 @@ object Types {
 
     override def underlying(implicit ctx: Context): Type = hi
 
+    /** Declared variances of type parameters, if bounds are type lambdas,
+     *  or Nil if bounds are not lambdas or type parameters are non-variant.
+     */
+    def variances: List[Int] = Nil
+
+    def withVariances(vs: List[Int])(implicit ctx: Context): TypeBounds =
+      if vs eq variances then this else TypeBounds(lo, hi, vs)
+
     /** The non-alias type bounds type with given bounds */
     def derivedTypeBounds(lo: Type, hi: Type)(implicit ctx: Context): TypeBounds =
       if ((lo eq this.lo) && (hi eq this.hi)) this
@@ -4296,19 +4304,41 @@ object Types {
 
     override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: AliasingBounds => false
-      case that: TypeBounds => lo.equals(that.lo, bs) && hi.equals(that.hi, bs)
+      case that: TypeBounds => lo.equals(that.lo, bs) && hi.equals(that.hi, bs) && that.variances.isEmpty
       case _ => false
     }
 
     override def eql(that: Type): Boolean = that match {
       case that: AliasingBounds => false
-      case that: TypeBounds => lo.eq(that.lo) && hi.eq(that.hi)
+      case that: TypeBounds => lo.eq(that.lo) && hi.eq(that.hi) && that.variances.isEmpty
       case _ => false
     }
   }
 
   class RealTypeBounds(lo: Type, hi: Type) extends TypeBounds(lo, hi)
 
+  class VariantTypeBounds(lo: Type, hi: Type, variances: List[Int] = Nil) extends RealTypeBounds(lo, hi) {
+
+    /** The non-alias type bounds type with given bounds */
+    override def derivedTypeBounds(lo: Type, hi: Type)(implicit ctx: Context): TypeBounds =
+      if (lo eq this.lo) && (hi eq this.hi) then this
+      else TypeBounds(lo, hi, variances)
+
+    override def computeHash(bs: Binders): Int = doHash(bs, variances, lo, hi)
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: AliasingBounds => false
+      case that: TypeBounds => lo.equals(that.lo, bs) && hi.equals(that.hi, bs) && that.variances == variances
+      case _ => false
+    }
+
+    override def eql(that: Type): Boolean = that match {
+      case that: AliasingBounds => false
+      case that: TypeBounds => lo.eq(that.lo) && hi.eq(that.hi) && that.variances == variances
+      case _ => false
+    }
+  }
+
   /** Common supertype of `TypeAlias` and `MatchAlias` */
   abstract class AliasingBounds(val alias: Type) extends TypeBounds(alias, alias) {
 
@@ -4352,6 +4382,9 @@ object Types {
   object TypeBounds {
     def apply(lo: Type, hi: Type)(implicit ctx: Context): TypeBounds =
       unique(new RealTypeBounds(lo, hi))
+    def apply(lo: Type, hi: Type, variances: List[Int])(implicit ctx: Context): TypeBounds =
+      if variances.forall(_ == 0) then apply(lo, hi)
+      else unique(new VariantTypeBounds(lo, hi, variances))
     def empty(implicit ctx: Context): TypeBounds = apply(defn.NothingType, defn.AnyType)
     def upper(hi: Type)(implicit ctx: Context): TypeBounds = apply(defn.NothingType, hi)
     def lower(lo: Type)(implicit ctx: Context): TypeBounds = apply(lo, defn.AnyType)

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

@@ -234,7 +234,11 @@ class TreePickler(pickler: TastyPickler) {
       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)
+        for v <- tpe.variances do writeNat(v + 1)
+      }
     case tpe: AnnotatedType =>
       writeByte(ANNOTATEDtype)
       withLength { pickleType(tpe.parent, richTypes); pickleTree(tpe.annot.tree) }

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

@@ -337,7 +337,7 @@ class TreeUnpickler(reader: TastyReader,
               val lo = readType()
               val hi = readType()
               if (lo.isMatch && (lo `eq` hi)) MatchAlias(lo)
-              else TypeBounds(lo, hi)
+              else TypeBounds(lo, hi).withVariances(until(end)(readNat() - 1))
             case ANNOTATEDtype =>
               AnnotatedType(readType(), Annotation(readTerm()))
             case ANDtype =>

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

@@ -46,6 +46,7 @@ Macro-format:
                       // If positive, this is a NameRef for the fully qualified name of a term parameter.
 
   NameRef       = Nat                    // ordinal number of name in name table, starting from 1.
+  Variance      = Nat                    // 0 = contravariant, 1 = nonvariant, 2 = covariant
 
 Note: Unqualified names in the name table are strings. The context decides whether a name is
 a type-name or a term-name. The same string can represent both.
@@ -154,7 +155,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 low_Type high_Type Variance*               -- >: low <: high, possibly with variances of parameters of lambdas in bounds
                   ANNOTATEDtype  Length underlying_Type annotation_Term            -- underlying @ annotation
                   ANDtype        Length left_Type right_Type                       -- left & right
                   ORtype         Length left_Type right_Type                       -- lefgt | right