Implement base variance ops

 + refactoring: account for Bivariance
 + refactpring: collect variance related ops in Variances,
   move Variances to core.

Author: odersky

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

@@ -10,6 +10,7 @@ import Decorators._
 import util.Stats._
 import Names._
 import NameOps._
+import Variances.{varianceConforms, variancesConform}
 import dotty.tools.dotc.config.Config
 
 object TypeApplications {
@@ -22,24 +23,6 @@ object TypeApplications {
     case _ => tp
   }
 
-  /** Does variance `v1` conform to variance `v2`?
-   *  This is the case if the variances are the same or `sym` is nonvariant.
-   */
-  def varianceConforms(v1: Int, v2: Int): Boolean =
-    v1 == v2 || v2 == 0
-
-  /** Does the variance of type parameter `tparam1` conform to the variance of type parameter `tparam2`?
-   */
-  def varianceConforms(tparam1: TypeParamInfo, tparam2: TypeParamInfo)(implicit ctx: Context): Boolean =
-    varianceConforms(tparam1.paramVariance, tparam2.paramVariance)
-
-  /** Do the variances of type parameters `tparams1` conform to the variances
-   *  of corresponding type parameters `tparams2`?
-   *  This is only the case of `tparams1` and `tparams2` have the same length.
-   */
-  def variancesConform(tparams1: List[TypeParamInfo], tparams2: List[TypeParamInfo])(implicit ctx: Context): Boolean =
-    tparams1.corresponds(tparams2)(varianceConforms)
-
   /** Extractor for
    *
    *    [v1 X1: B1, ..., vn Xn: Bn] -> C[X1, ..., Xn]

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

@@ -11,6 +11,7 @@ import config.Config
 import config.Printers.{constr, subtyping, gadts, noPrinter}
 import TypeErasure.{erasedLub, erasedGlb}
 import TypeApplications._
+import Variances.variancesConform
 import Constants.Constant
 import transform.TypeUtils._
 import transform.SymUtils._

compiler/src/dotty/tools/dotc/typer/Variances.scala renamed to compiler/src/dotty/tools/dotc/core/Variances.scala

@@ -1,15 +1,20 @@
 package dotty.tools.dotc
-package typer
+package core
 
-import core._
 import Types._, Contexts._, Flags._, Symbols._, Annotations._
+import TypeApplications.TypeParamInfo
 
 object Variances {
 
   type Variance = FlagSet
   val Bivariant: Variance = VarianceFlags
   val Invariant: Variance = EmptyFlags
 
+  def varianceFromInt(v: Int) =
+    if v < 0 then Covariant
+    else if v > 0 then Contravariant
+    else Invariant
+
   /** Flip between covariant and contravariant */
   def flip(v: Variance): Variance =
     if (v == Covariant) Contravariant
@@ -98,6 +103,53 @@ object Variances {
       Bivariant
   }
 
+  /** A map from the index of a lambda parameter to its variance in -1 .. 1 */
+  type ParamVarianceMap = Map[Int, Int]
+
+  def lambdaVariances(lam: HKTypeLambda)(implicit ctx: Context): ParamVarianceMap =
+    object accu extends TypeAccumulator[ParamVarianceMap] {
+      def apply(vmap: ParamVarianceMap, t: Type): ParamVarianceMap = t match {
+        case t: TypeParamRef if t.binder eq lam =>
+          val idx = t.paramNum
+          vmap.get(idx) match
+            case None =>
+              vmap.updated(idx, variance)
+            case Some(v) =>
+              if v == variance || v == 0 then vmap else vmap.updated(idx, 0)
+        case _ =>
+          foldOver(vmap, t)
+      }
+    }
+    accu(Map(), lam.resType)
+
+  /** Does variance `v1` conform to variance `v2`?
+   *  This is the case if the variances are the same or `sym` is nonvariant.
+   */
+   def varianceConforms(v1: Int, v2: Int): Boolean =
+    v1 == v2 || v2 == 0
+
+  /** Does the variance of type parameter `tparam1` conform to the variance of type parameter `tparam2`?
+   */
+   def varianceConforms(tparam1: TypeParamInfo, tparam2: TypeParamInfo)(implicit ctx: Context): Boolean =
+    varianceConforms(tparam1.paramVariance, tparam2.paramVariance)
+
+  /** Do the variances of type parameters `tparams1` conform to the variances
+   *  of corresponding type parameters `tparams2`?
+   *  This is only the case of `tparams1` and `tparams2` have the same length.
+   */
+  def variancesConform(tparams1: List[TypeParamInfo], tparams2: List[TypeParamInfo])(implicit ctx: Context): Boolean =
+    tparams1.corresponds(tparams2)(varianceConforms)
+
+  def variancesConform(vs1: List[Variance], vs2: List[Variance]): Boolean = vs2 match
+    case v2 :: rest2 =>
+      vs1 match
+        case v1 :: rest1 => v1.isAllOf(v2) && variancesConform(rest1, rest2)
+        case nil => v2.isEmpty && variancesConform(vs1, rest2)
+    case nil => true
+
+  def varianceString(sym: Symbol)(implicit ctx: Context): String =
+    varianceString(sym.variance)
+
   def varianceString(v: Variance): String =
     if (v is Covariant) "covariant"
     else if (v is Contravariant) "contravariant"

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -8,6 +8,7 @@ import StdNames.nme
 import ast.Trees._
 import typer.Implicits._
 import typer.ImportInfo
+import Variances.varianceString
 import util.SourcePosition
 import java.lang.Integer.toOctalString
 import config.Config.summarizeDepth
@@ -415,15 +416,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
   protected def toTextFlags(sym: Symbol, flags: FlagSet): Text =
     Text(flags.flagStrings(privateWithinString(sym)).map(flag => stringToText(keywordStr(flag))), " ")
 
-  /** String representation of symbol's variance or "" if not applicable */
-  protected def varianceString(sym: Symbol): String = varianceString(sym.variance)
-
-  protected def varianceString(v: Int): String = v match {
-    case -1 => "-"
-    case 1 => "+"
-    case _ => ""
-  }
-
   def annotsText(sym: Symbol): Text = Text(sym.annotations.map(toText))
 
   def dclText(sym: Symbol): Text = dclTextWithInfo(sym, sym.unforcedInfo)

compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala

@@ -7,7 +7,6 @@ import Types._, Contexts._, Flags._, Symbols._, Trees._
 import Decorators._
 import Variances._
 import NameKinds._
-import TypeApplications.varianceConforms
 import util.Spans._
 import util.SourcePosition
 import config.Printers.variances