Make useVariances tunable

Needs to be passed as a parameter since Namer does not construct
a bounds immediately.

Author: odersky

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

@@ -3564,29 +3564,32 @@ object Types {
       apply(syntheticParamNames(n))(
         pt => List.fill(n)(TypeBounds.empty), pt => defn.AnyType)
 
+    override def fromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], resultType: Type)(implicit ctx: Context): Type =
+      fromParams(params, resultType, useVariances = resultType.isInstanceOf[TypeBounds])
+
     /** Distributes Lambda inside type bounds. Examples:
      *
      *      type T[X] = U        becomes    type T = [X] -> U
      *      type T[X] <: U       becomes    type T >: Nothing <: ([X] -> U)
      *      type T[X] >: L <: U  becomes    type T >: ([X] -> L) <: ([X] -> U)
      */
-    override def fromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], resultType: Type)(implicit ctx: Context): Type = {
-      def expand(tp: Type, useVariances: Boolean) = params match
-        case (param: Symbol) :: _ if useVariances =>
+    def fromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], resultType: Type, useVariances: Boolean)(implicit ctx: Context): Type = {
+      def expand(tp: Type, useVariances: Boolean) =
+        if params.nonEmpty then
           apply(params.map(_.paramName), params.map(_.paramVariance))(
             tl => params.map(param => toPInfo(tl.integrate(params, param.paramInfo))),
-            tl => tl.integrate(params, tp.resultType))
-        case _ =>
+            tl => tl.integrate(params, tp))
+        else
           super.fromParams(params, tp)
       resultType match {
         case rt: AliasingBounds =>
-          rt.derivedAlias(expand(rt.alias, true))
+          rt.derivedAlias(expand(rt.alias, useVariances))
         case rt @ TypeBounds(lo, hi) =>
           rt.derivedTypeBounds(
             if (lo.isRef(defn.NothingClass)) lo else expand(lo, false),
-            expand(hi, true))
+            expand(hi, useVariances))
         case rt =>
-          expand(rt, false)
+          expand(rt, useVariances)
       }
     }
   }

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

@@ -1505,7 +1505,7 @@ class Namer { typer: Typer =>
   }
 
   def typeDefSig(tdef: TypeDef, sym: Symbol, tparamSyms: List[TypeSymbol])(implicit ctx: Context): Type = {
-    def abstracted(tp: Type): Type = HKTypeLambda.fromParams(tparamSyms, tp)
+    def abstracted(tp: Type): Type = HKTypeLambda.fromParams(tparamSyms, tp, useVariances = true)
     val dummyInfo1 = abstracted(TypeBounds.empty)
     sym.info = dummyInfo1
     sym.setFlag(Provisional)

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

@@ -28,8 +28,11 @@ object VarianceChecker {
   def checkLambda(tree: tpd.LambdaTypeTree)(implicit ctx: Context): Unit = {
     def checkType(tl: HKTypeLambda): Unit = {
       val checkOK = new TypeAccumulator[Boolean] {
+        def paramVarianceSign(tref: TypeParamRef) =
+          tl.typeParams(tref.paramNum).paramVarianceSign
         def error(tref: TypeParamRef) = {
-          val VariantName(paramName, v) = tl.paramNames(tref.paramNum).toTermName
+          val paramName = tl.paramNames(tref.paramNum).toTermName
+          val v = paramVarianceSign(tref)
           val paramVarianceStr = if (v == 0) "contra" else "co"
           val occursStr = variance match {
             case -1 => "contra"
@@ -45,7 +48,7 @@ object VarianceChecker {
         def apply(x: Boolean, t: Type) = x && {
           t match {
             case tref: TypeParamRef if tref.binder `eq` tl =>
-              val v = tl.typeParams(tref.paramNum).paramVarianceSign
+              val v = paramVarianceSign(tref)
               varianceConforms(variance, v) || { error(tref); false }
             case AnnotatedType(_, annot) if annot.symbol == defn.UncheckedVarianceAnnot =>
               x