Abstract over paramVariance instead of paramVarianceSign

Author: odersky

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

@@ -3,6 +3,7 @@ package dotty.tools.dotc.core
 import Names.Name
 import Contexts.Context
 import Types.Type
+import Variances.{Variance, varianceToInt}
 
 /** A common super trait of Symbol and LambdaParam.
  *  Used to capture the attributes of type parameters which can be implemented as either.
@@ -35,7 +36,13 @@ trait ParamInfo {
   def paramInfoOrCompleter(implicit ctx: Context): Type
 
   /** The variance of the type parameter */
-  def paramVarianceSign(implicit ctx: Context): Int
+  def paramVariance(implicit ctx: Context): Variance
+
+  /** The variance of the type parameter, as a number -1, 0, +1.
+   *  Bivariant is mapped to 1, i.e. it is treated like Covariant.
+   */
+  final def paramVarianceSign(implicit ctx: Context): Int =
+    varianceToInt(paramVariance)
 
   /** A type that refers to the parameter */
   def paramRef(implicit ctx: Context): Type

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

@@ -22,6 +22,7 @@ import ast.tpd
 import tpd.{Tree, TreeProvider, TreeOps}
 import ast.TreeTypeMap
 import Constants.Constant
+import Variances.{Variance, varianceFromInt}
 import reporting.diagnostic.Message
 import collection.mutable
 import io.AbstractFile
@@ -699,7 +700,7 @@ object Symbols {
     def paramInfo(implicit ctx: Context): Type = denot.info
     def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context): Type = pre.memberInfo(this)
     def paramInfoOrCompleter(implicit ctx: Context): Type = denot.infoOrCompleter
-    def paramVarianceSign(implicit ctx: Context): Int = denot.variance
+    def paramVariance(implicit ctx: Context): Variance = varianceFromInt(denot.variance)
     def paramRef(implicit ctx: Context): TypeRef = denot.typeRef
 
 // -------- Printing --------------------------------------------------------

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

@@ -3458,14 +3458,14 @@ object Types {
 
     private def setVariances(tparams: List[LambdaParam], vs: List[Variance]): Unit =
       if tparams.nonEmpty then
-        tparams.head.setVariance(vs.head)
+        tparams.head.givenVariance = vs.head
         setVariances(tparams.tail, vs.tail)
 
     val isVariant = variances.nonEmpty
     if isVariant then setVariances(typeParams, variances)
 
     def givenVariances =
-      if isVariant then typeParams.map(_.paramVariance)
+      if isVariant then typeParams.map(_.givenVariance)
       else Nil
 
     override def computeHash(bs: Binders): Int =
@@ -3479,7 +3479,7 @@ object Types {
         && isVariant == that.isVariant
         && (!isVariant
             || typeParams.corresponds(that.typeParams)((x, y) =>
-                  x.paramVariance == y.paramVariance))
+                  x.givenVariance == y.givenVariance))
         && {
           val bs1 = new BinderPairs(this, that, bs)
           paramInfos.equalElements(that.paramInfos, bs1) &&
@@ -3620,12 +3620,17 @@ object Types {
     def paramInfo(implicit ctx: Context): tl.PInfo = tl.paramInfos(n)
     def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context): tl.PInfo = paramInfo
     def paramInfoOrCompleter(implicit ctx: Context): Type = paramInfo
-    def paramVarianceSign(implicit ctx: Context): Int = tl.paramNames(n).variance
     def paramRef(implicit ctx: Context): Type = tl.paramRefs(n)
 
     private var myVariance: FlagSet = UndefinedFlags
-    def setVariance(v: Variance): Unit = myVariance = v
-    def paramVariance: Variance =
+    def givenVariance_=(v: Variance): Unit =
+      assert(myVariance == UndefinedFlags)
+      myVariance = v
+    def givenVariance: Variance =
+      assert(myVariance != UndefinedFlags)
+      myVariance
+
+    def paramVariance(implicit ctx: Context): Variance =
       if myVariance == UndefinedFlags then
         myVariance = varianceFromInt(tl.paramNames(n).variance)
       myVariance