Don't treat opaque aliases structurally

Author: odersky

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

@@ -3564,39 +3564,55 @@ object Types {
         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])
+      resultType match
+        case bounds: TypeBounds => boundsFromParams(params, bounds)
+        case _ => super.fromParams(params, resultType)
 
     /** 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)
      *
-     *  @param  useVariances  If true, set parameter variances of the type lambda to be as in `params`,
-     *                        If false, TypeBounds types and match aliases aways get their variances set
-     *                        and type aliases get variances set if some parameter is not invariant,
-     *                        but variances of parameters of other types are determined structurally,
-     *                        by looking how the parameter is used in the result type.
+     *  The variances of regular TypeBounds types, as well as of match aliases
+     *  and of opaque aliases are always determined from the given parameters
+     *  `params`. The variances of other type aliases are determined from
+     *  the given parameters only if one of these parameters carries a `+`
+     *  or `-` variance annotation. Type aliases without variance annotation
+     *  are treated structurally. That is, their parameter variances are
+     *  determined by how the parameter(s) appear in the result type.
+     *
+     *  Examples:
+     *
+     *    type T[X] >: A              // X is invariant
+     *    type T[X] <: List[X]        // X is invariant
+     *    type T[X] = List[X]         // X is covariant (determined structurally)
+     *    opaque type T[X] = List[X]  // X is invariant
+     *    opaque type T[+X] = List[X] // X is covariant
+     *    type T[A, B] = A => B       // A is contravariant, B is covariant (determined structurally)
+     *    type T[A, +B] = A => B      // A is invariant, B is covariant
      */
-    def fromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], resultType: Type, useVariances: Boolean)(implicit ctx: Context): Type = {
+    def boundsFromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], bounds: TypeBounds)(implicit ctx: Context): TypeBounds = {
       def expand(tp: Type, useVariances: Boolean) =
         if params.nonEmpty && useVariances then
           apply(params.map(_.paramName), params.map(_.paramVariance))(
             tl => params.map(param => toPInfo(tl.integrate(params, param.paramInfo))),
             tl => tl.integrate(params, tp))
         else
           super.fromParams(params, tp)
-      resultType match {
-        case rt: MatchAlias =>
-          rt.derivedAlias(expand(rt.alias, true))
-        case rt: TypeAlias =>
-          rt.derivedAlias(expand(rt.alias, params.exists(!_.paramVariance.isEmpty)))
-        case rt @ TypeBounds(lo, hi) =>
-          rt.derivedTypeBounds(
-            if (lo.isRef(defn.NothingClass)) lo else expand(lo, true),
+      def isOpaqueAlias = params match
+        case (param: Symbol) :: _ => param.owner.is(Opaque)
+        case _ => false
+      bounds match {
+        case bounds: MatchAlias =>
+          bounds.derivedAlias(expand(bounds.alias, true))
+        case bounds: TypeAlias =>
+          bounds.derivedAlias(expand(bounds.alias,
+            isOpaqueAlias | params.exists(!_.paramVariance.isEmpty)))
+        case TypeBounds(lo, hi) =>
+          bounds.derivedTypeBounds(
+            if lo.isRef(defn.NothingClass) then lo else expand(lo, true),
             expand(hi, true))
-        case rt =>
-          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, useVariances = true)
+    def abstracted(tp: TypeBounds): TypeBounds = HKTypeLambda.boundsFromParams(tparamSyms, tp)
     val dummyInfo1 = abstracted(TypeBounds.empty)
     sym.info = dummyInfo1
     sym.setFlag(Provisional)
@@ -1535,9 +1535,8 @@ class Namer { typer: Typer =>
     }
     sym.info = dummyInfo2
 
-    val rhsBodyType = typedAheadType(rhs).tpe
-    val rhsType = if (isDerived) rhsBodyType else abstracted(rhsBodyType)
-    val unsafeInfo = rhsType.toBounds
+    val rhsBodyType: TypeBounds = typedAheadType(rhs).tpe.toBounds
+    val unsafeInfo = if (isDerived) rhsBodyType else abstracted(rhsBodyType)
     if (isDerived) sym.info = unsafeInfo
     else {
       sym.info = NoCompleter