Address review comments

Author: odersky

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

@@ -1934,6 +1934,15 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
       if (t2.exists) t2
       else if (isErased) erasedGlb(tp1, tp2, isJava = false)
       else liftIfHK(tp1, tp2, op, original, _ | _)
+        // The ` | ` on variances is needed since variances are associated with bounds
+        // not lambdas. Example:
+        //
+        //    trait A { def F[-X] }
+        //    trait B { def F[+X] }
+        //    object O extends A, B { ... }
+        //
+        // Here, `F` is treated as bivariant in `O`. That is, only bivariant implementation
+        // of `F` are allowed.
     }
   }
 
@@ -2004,7 +2013,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
       HKTypeLambda(
         paramNames = HKTypeLambda.syntheticParamNames(tparams1.length),
         variances =
-          if tp1.isVariantLambda && tp2.isVariantLambda then
+          if tp1.isDeclaredVarianceLambda && tp2.isDeclaredVarianceLambda then
             tparams1.lazyZip(tparams2).map((p1, p2) => combineVariance(p1.paramVariance, p2.paramVariance))
           else Nil
       )(

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

@@ -368,7 +368,7 @@ object Types {
     }
 
     /** Is this a higher-kinded type lambda with given parameter variances? */
-    def isVariantLambda: Boolean = false
+    def isDeclaredVarianceLambda: Boolean = false
 
 // ----- Higher-order combinators -----------------------------------
 
@@ -3433,15 +3433,19 @@ object Types {
   }
 
   /** A type lambda of the form `[X_0 B_0, ..., X_n B_n] => T`
-   *  Variances are encoded in parameter names. A name starting with `+`
-   *  designates a covariant parameter, a name starting with `-` designates
-   *  a contravariant parameter, and every other name designates a non-variant parameter.
+   *  Variances are encoded in parameter names. A
    *
    *  @param  paramNames      The names `X_0`, ..., `X_n`
    *  @param  paramInfosExp  A function that, given the polytype itself, returns the
    *                          parameter bounds `B_1`, ..., `B_n`
    *  @param  resultTypeExp   A function that, given the polytype itself, returns the
    *                          result type `T`.
+   *  @param  variances       The variances of the type parameters, if the type lambda
+   *                          carries variances, i.e. it is a bound of an abstract type
+   *                          or the rhs of a match alias or opaque alias. The parameter
+   *                          is Nil for all other lambdas.
+   *
+   *  Variances are stored in the `typeParams` list of the lambda.
    */
   class HKTypeLambda(val paramNames: List[TypeName], @constructorOnly variances: List[Variance])(
       paramInfosExp: HKTypeLambda => List[TypeBounds], resultTypeExp: HKTypeLambda => Type)
@@ -3457,28 +3461,28 @@ object Types {
 
     private def setVariances(tparams: List[LambdaParam], vs: List[Variance]): Unit =
       if tparams.nonEmpty then
-        tparams.head.givenVariance = vs.head
+        tparams.head.declaredVariance = vs.head
         setVariances(tparams.tail, vs.tail)
 
-    override val isVariantLambda = variances.nonEmpty
-    if isVariantLambda then setVariances(typeParams, variances)
+    override val isDeclaredVarianceLambda = variances.nonEmpty
+    if isDeclaredVarianceLambda then setVariances(typeParams, variances)
 
-    def givenVariances =
-      if isVariantLambda then typeParams.map(_.givenVariance)
+    def declaredVariances =
+      if isDeclaredVarianceLambda then typeParams.map(_.declaredVariance)
       else Nil
 
     override def computeHash(bs: Binders): Int =
-      doHash(new Binders(this, bs), givenVariances ::: paramNames, resType, paramInfos)
+      doHash(new Binders(this, bs), declaredVariances ::: paramNames, resType, paramInfos)
 
     // No definition of `eql` --> fall back on equals, which calls iso
 
     final override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: HKTypeLambda =>
         paramNames.eqElements(that.paramNames)
-        && isVariantLambda == that.isVariantLambda
-        && (!isVariantLambda
+        && isDeclaredVarianceLambda == that.isDeclaredVarianceLambda
+        && (!isDeclaredVarianceLambda
             || typeParams.corresponds(that.typeParams)((x, y) =>
-                  x.givenVariance == y.givenVariance))
+                  x.declaredVariance == y.declaredVariance))
         && {
           val bs1 = new BinderPairs(this, that, bs)
           paramInfos.equalElements(that.paramInfos, bs1) &&
@@ -3489,7 +3493,7 @@ object Types {
     }
 
     override def newLikeThis(paramNames: List[ThisName], paramInfos: List[PInfo], resType: Type)(implicit ctx: Context): This =
-      newLikeThis(paramNames, givenVariances, paramInfos, resType)
+      newLikeThis(paramNames, declaredVariances, paramInfos, resType)
 
     def newLikeThis(paramNames: List[ThisName], variances: List[Variance], paramInfos: List[PInfo], resType: Type)(implicit ctx: Context): This =
       HKTypeLambda(paramNames, variances)(
@@ -3501,8 +3505,8 @@ object Types {
 
     protected def prefixString: String = "HKTypeLambda"
     final override def toString: String =
-      if isVariantLambda then
-        s"HKTypeLambda($paramNames, $paramInfos, $resType, ${givenVariances.map(_.flagsString)})"
+      if isDeclaredVarianceLambda then
+        s"HKTypeLambda($paramNames, $paramInfos, $resType, ${declaredVariances.map(_.flagsString)})"
       else super.toString
   }
 
@@ -3612,7 +3616,7 @@ object Types {
           bounds.derivedAlias(expand(bounds.alias, true))
         case bounds: TypeAlias =>
           bounds.derivedAlias(expand(bounds.alias,
-            isOpaqueAlias | params.exists(!_.paramVariance.isEmpty)))
+            isOpaqueAlias || params.exists(!_.paramVariance.isEmpty)))
         case TypeBounds(lo, hi) =>
           bounds.derivedTypeBounds(
             if lo.isRef(defn.NothingClass) then lo else expand(lo, true),
@@ -3659,18 +3663,32 @@ object Types {
     def paramRef(implicit ctx: Context): Type = tl.paramRefs(n)
 
     private var myVariance: FlagSet = UndefinedFlags
+
+    /** Low level setter, only called from Variances.setStructuralVariances */
     def storedVariance_= (v: Variance): Unit =
       myVariance = v
+
+    /** Low level getter, only called from Variances.setStructuralVariances */
     def storedVariance: Variance =
       myVariance
 
-    def givenVariance_=(v: Variance): Unit =
+    /** Set the declared variance of this parameter.
+     *  @pre the containing lambda is a isDeclaredVarianceLambda
+     */
+    def declaredVariance_=(v: Variance): Unit =
+      assert(tl.isDeclaredVarianceLambda)
       assert(myVariance == UndefinedFlags)
       myVariance = v
-    def givenVariance: Variance =
+
+    /** The declared variance of this parameter.
+     *  @pre the containing lambda is a isDeclaredVarianceLambda
+     */
+    def declaredVariance: Variance =
+      assert(tl.isDeclaredVarianceLambda)
       assert(myVariance != UndefinedFlags)
       myVariance
 
+    /** The declared or structural variance of this parameter. */
     def paramVariance(implicit ctx: Context): Variance =
       if myVariance == UndefinedFlags then
         tl match

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

@@ -110,19 +110,19 @@ object Variances {
   }
 
   def setStructuralVariances(lam: HKTypeLambda)(implicit ctx: Context): Unit =
-    assert(!lam.isVariantLambda)
+    assert(!lam.isDeclaredVarianceLambda)
     for param <- lam.typeParams do param.storedVariance = Bivariant
-    object traverse extends TypeAccumulator[Unit] {
-      def apply(x: Unit, t: Type): Unit = t match
+    object narrowVariances extends TypeTraverser {
+      def traverse(t: Type): Unit = t match
         case t: TypeParamRef if t.binder eq lam =>
           lam.typeParams(t.paramNum).storedVariance &= varianceFromInt(variance)
         case _ =>
-          foldOver(x, t)
+          traverseChildren(t)
     }
     // Note: Normally, we'd need to repeat `traverse` until a fixpoint is reached.
-    // But since recursive lambdas can only appear in bounds, and bound never have
+    // But since recursive lambdas can only appear in bounds, and bounds never have
     // structural variances, a single traversal is enough.
-    traverse((), lam.resType)
+    narrowVariances.traverse(lam.resType)
 
   /** Does variance `v1` conform to variance `v2`?
    *  This is the case if the variances are the same or `sym` is nonvariant.
@@ -137,12 +137,12 @@ object Variances {
 
   /** 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.
+   *  This is only the case if `tparams1` and `tparams2` have the same length.
    */
   def variancesConform(tparams1: List[TypeParamInfo], tparams2: List[TypeParamInfo])(implicit ctx: Context): Boolean =
     val needsDetailedCheck = tparams2 match
       case (_: Symbol) :: _ => true
-      case LambdaParam(tl: HKTypeLambda, _) :: _ => tl.isVariantLambda
+      case LambdaParam(tl: HKTypeLambda, _) :: _ => tl.isDeclaredVarianceLambda
       case _ => false
     if needsDetailedCheck then tparams1.corresponds(tparams2)(varianceConforms)
     else tparams1.hasSameLengthAs(tparams2)

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

@@ -135,8 +135,8 @@ class TreePickler(pickler: TastyPickler) {
   }
 
   def pickleVariances(tp: Type)(given Context): Unit = tp match
-    case tp: HKTypeLambda if tp.isVariantLambda =>
-      for v <- tp.givenVariances do
+    case tp: HKTypeLambda if tp.isDeclaredVarianceLambda =>
+      for v <- tp.declaredVariances do
         writeByte(
           if v.is(Covariant) then COVARIANT
           else if v.is(Contravariant) then CONTRAVARIANT

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

@@ -331,8 +331,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
     def decompose(tp: Type) = tp.stripTypeVar match
       case lam: HKTypeLambda =>
         val names =
-          if lam.isVariantLambda then
-            lam.paramNames.lazyZip(lam.givenVariances).map((name, v) =>
+          if lam.isDeclaredVarianceLambda then
+            lam.paramNames.lazyZip(lam.declaredVariances).map((name, v) =>
               varianceSign(v) + name)
           else lam.paramNames
         (names.mkString("[", ", ", "]"), lam.resType)

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

@@ -27,7 +27,7 @@ object VarianceChecker {
    */
   def checkLambda(tree: tpd.LambdaTypeTree, bounds: TypeBounds)(implicit ctx: Context): Unit =
     def checkType(tpe: Type): Unit = tpe match
-      case tl: HKTypeLambda if tl.isVariantLambda =>
+      case tl: HKTypeLambda if tl.isDeclaredVarianceLambda =>
         val checkOK = new TypeAccumulator[Boolean] {
           def paramVarianceSign(tref: TypeParamRef) =
             tl.typeParams(tref.paramNum).paramVarianceSign

docs/docs/reference/new-types/type-lambdas-spec.md

@@ -38,8 +38,6 @@ its eta expansion. I.e, `List = [X] =>> List[X]`. This allows type constructors
 
 ## Relationship with Parameterized Type Definitions
 
-type F[X] <: List[F[X]]
-
 A parameterized type definition
 ```scala
 type T[X] = R
@@ -53,7 +51,7 @@ it is checked that the variance annotations are satisfied by the type lambda.
 For instance,
 ```scala
 type F2[A, +B] = A => B
-```scala
+```
 expands to
 ```scala
 type F2 = [A, B] =>> A => B

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

@@ -211,7 +211,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   OPEN                                                             -- an open class
                   Annotation
 
-  Variance      = SEALED                                                           -- invariant
+  Variance      = STABLE                                                           -- invariant
                 | COVARIANT
                 | CONTRAVARIANT