Simplify capture conversion scheme

Instead of computing a new type where each wildcard argument is
replaced by `<some skolem>.CAP`, we can simply introduce a skolem
for the tree's type instead. This well turn the type into a singleton
so that then the capture conversions for singletons in isSubArgs
can kick in.

Author: odersky

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

@@ -755,10 +755,6 @@ class Definitions {
 
     def Eql_eqlAny(implicit ctx: Context): TermSymbol = EqlModule.requiredMethod(nme.eqlAny)
 
-  lazy val TypeBoxType: TypeRef = ctx.requiredClassRef("scala.internal.TypeBox")
-
-    lazy val TypeBox_CAP: TypeSymbol = TypeBoxType.symbol.requiredType(tpnme.CAP)
-
   lazy val NotType: TypeRef = ctx.requiredClassRef("scala.implicits.Not")
   def NotClass(implicit ctx: Context): ClassSymbol = NotType.symbol.asClass
   def NotModule(implicit ctx: Context): Symbol = NotClass.companionModule

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

@@ -326,7 +326,6 @@ object StdNames {
     val AnnotatedType: N        = "AnnotatedType"
     val AppliedTypeTree: N      = "AppliedTypeTree"
     val ArrayAnnotArg: N        = "ArrayAnnotArg"
-    val CAP: N                  = "CAP"
     val Constant: N             = "Constant"
     val ConstantType: N         = "ConstantType"
     val doubleHash: N           = "doubleHash"

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

@@ -1041,7 +1041,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
             arg1 match {
               case arg1: TypeBounds =>
 	            tparam match {
-	              case tparam: Symbol if leftRoot.isStable || ctx.isAfterTyper =>
+	              case tparam: Symbol
+                if leftRoot.isStable || ctx.isAfterTyper || ctx.mode.is(Mode.TypevarsMissContext) =>
 	                val captured = TypeRef(leftRoot, tparam)
 	                isSubArg(captured, arg2)
 	              case _ =>

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

@@ -2698,46 +2698,26 @@ class Typer extends Namer
       case tree: Closure => cpy.Closure(tree)(tpt = TypeTree(pt)).withType(pt)
     }
 
-    /** Replace every top-level occurrence of a wildcard type argument by
-    *  a skolem type
-    */
-    def captureWildcards(tp: Type)(implicit ctx: Context): Type = tp match {
-      case tp: AndOrType => tp.derivedAndOrType(captureWildcards(tp.tp1), captureWildcards(tp.tp2))
-      case tp: RefinedType => tp.derivedRefinedType(captureWildcards(tp.parent), tp.refinedName, tp.refinedInfo)
-      case tp: RecType => tp.derivedRecType(captureWildcards(tp.parent))
-      case tp: LazyRef => captureWildcards(tp.ref)
-      case tp: AnnotatedType => tp.derivedAnnotatedType(captureWildcards(tp.parent), tp.annot)
-      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)
-              }
-            tp.derivedAppliedType(tycon, args1)
-          case _ =>
-            tp
-        }
-      case _ => tp
+    def hasWildcardArg(tp: Type): Boolean = tp match {
+      case tp: AppliedType => tp.hasWildcardArg
+      case tp: AndOrType => hasWildcardArg(tp.tp1) || hasWildcardArg(tp.tp2)
+      case _: SingletonType | _: HKTypeLambda => false
+      case tp: TypeProxy => hasWildcardArg(tp.superType)
+      case _ => false
     }
 
     def adaptToSubType(wtp: Type): Tree = {
       // try converting a constant to the target type
       val folded = ConstFold(tree, pt)
-      if (folded ne tree) return adaptConstant(folded, folded.tpe.asInstanceOf[ConstantType])
-
-      // Try to capture wildcards in type
-      val captured = captureWildcards(wtp)
-      if (captured `ne` wtp) return readapt(tree.cast(captured))
+      if (folded ne tree)
+        return adaptConstant(folded, folded.tpe.asInstanceOf[ConstantType])
+
+      // If tree's type is not stable and has wildcard arguments, make it
+      // stable by casting it to a skolem. I.e. a tree `t` of widened type `T`
+      // gets widened to `t.$asInstanceOf$[SkolemType(T)]`. This will enable
+      // capture comversion in the subsequent subtype check.
+      if (!tree.tpe.isStable && hasWildcardArg(wtp) && !ctx.isAfterTyper)
+        return readapt(tree.cast(SkolemType(wtp)))
 
       // drop type if prototype is Unit
       if (pt isRef defn.UnitClass) {