Make SkolemTypes immutable and non-recursive.

Since we now map the info of a SkolemType as part of mapping the SkolemType
itself, it follows that SkolemTypes can't recursively refer to themselves.
So `captureWildcards` in `Typer` avoids recursion now by using an approximating
substitution instead (I wonder now how we ever could live without approximating
substitutions!). This means that SkolemTypes don't need to be mutable anymore
since there is no fixed point to construct.

Author: odersky

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

@@ -3618,12 +3618,8 @@ object Types {
 
   // ----- Skolem types -----------------------------------------------
 
-  /** A skolem type reference with underlying type `info`.
-   *  Note: `info` is a var, since this allows one to create a number of skolem types
-   *  and fill in their infos with types that refers to the skolem types recursively.
-   *  This is used in `captureWildcards` in `Typer`.
-   */
-  case class SkolemType(private[dotc] var info: Type) extends UncachedProxyType with ValueType with SingletonType {
+  /** A skolem type reference with underlying type `info` */
+  case class SkolemType(info: Type) extends UncachedProxyType with ValueType with SingletonType {
     override def underlying(implicit ctx: Context): Type = info
     def derivedSkolemType(info: Type)(implicit ctx: Context): SkolemType =
       if (info eq this.info) this else SkolemType(info)

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

@@ -2701,7 +2701,7 @@ class Typer extends Namer
     /** Replace every top-level occurrence of a wildcard type argument by
      *  a fresh skolem type. The skolem types are of the form $i.CAP, where
      *  $i is a skolem of type `scala.internal.TypeBox`, and `CAP` is its
-     *  type member.
+     *  type member. See the documentation of `TypeBox` for a rationale why we do this.
      */
     def captureWildcards(tp: Type)(implicit ctx: Context): Type = tp match {
       case tp: AndOrType => tp.derivedAndOrType(captureWildcards(tp.tp1), captureWildcards(tp.tp2))
@@ -2712,19 +2712,15 @@ class Typer extends Namer
       case tp @ AppliedType(tycon, args) if tp.hasWildcardArg =>
         tycon.typeParams match {
           case tparams @ ((_: Symbol) :: _) =>
-            val args1 = args.map {
-              case TypeBounds(lo, hi) =>
-                val skolem = SkolemType(defn.TypeBoxType.appliedTo(lo, hi))
-                TypeRef(skolem, defn.TypeBox_CAP)
-              case arg => arg
-            }
-            val boundss = tparams.map(_.paramInfo.subst(tparams.asInstanceOf[List[TypeSymbol]], args1))
-            for ((newArg, oldArg, bounds) <- (args1, args, boundss).zipped)
-              if (newArg `ne` oldArg) {
-                val TypeRef(skolem @ SkolemType(app @ AppliedType(typeBox, lo :: hi :: Nil)), _) = newArg
-                skolem.info = app.derivedAppliedType(
-                  typeBox, (lo | bounds.loBound) :: (hi & bounds.hiBound) :: Nil)
+            val boundss = tparams.map(_.paramInfo.substApprox(tparams.asInstanceOf[List[TypeSymbol]], args))
+            val args1 = args.zipWithConserve(boundss) { (arg, bounds) =>
+              arg match {
+                case TypeBounds(lo, hi) =>
+                  val skolem = SkolemType(defn.TypeBoxType.appliedTo(lo | bounds.loBound, hi & bounds.hiBound))
+                  TypeRef(skolem, defn.TypeBox_CAP)
+                case arg => arg
               }
+            }
             tp.derivedAppliedType(tycon, args1)
           case _ =>
             tp