Update decompiled files to account for new type tests

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -161,7 +161,7 @@ object Config {
   final val showCompletions = false
 
   /** If set, enables tracing */
-  final val tracingEnabled = false
+  final val tracingEnabled = true
 
   /** Initial capacity of uniques HashMap.
    *  Note: This MUST BE a power of two to work with util.HashSet

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

@@ -755,6 +755,10 @@ 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,6 +326,7 @@ 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/Types.scala

@@ -3610,7 +3610,7 @@ object Types {
   // ----- Skolem types -----------------------------------------------
 
   /** A skolem type reference with underlying type `binder`. */
-  case class SkolemType(info: Type) extends UncachedProxyType with ValueType with SingletonType {
+  case class SkolemType(var 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

@@ -79,6 +79,8 @@ object Typer {
    *  search was tried on a tree. This will in some cases be reported in error messages
    */
   private[typer] val HiddenSearchFailure = new Property.Key[SearchFailure]
+
+  val isBounds: Type => Boolean = _.isInstanceOf[TypeBounds]
 }
 
 class Typer extends Namer
@@ -1917,7 +1919,7 @@ class Typer extends Namer
           val elemTpes = (elems, pts).zipped.map((elem, pt) =>
             ctx.typeComparer.widenInferred(elem.tpe, pt))
           val resTpe = (elemTpes :\ (defn.UnitType: Type))(defn.PairType.appliedTo(_, _))
-          app1.asInstance(resTpe)
+          app1.cast(resTpe)
         }
       }
     }
@@ -2697,10 +2699,47 @@ 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 args.exists(isBounds) =>
+        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 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))
+
       // drop type if prototype is Unit
       if (pt isRef defn.UnitClass) {
         // local adaptation makes sure every adapted tree conforms to its pt
@@ -2709,6 +2748,7 @@ class Typer extends Namer
         checkStatementPurity(tree1)(tree, ctx.owner)
         return tpd.Block(tree1 :: Nil, Literal(Constant(())))
       }
+
       // convert function literal to SAM closure
       tree match {
         case closure(Nil, id @ Ident(nme.ANON_FUN), _)
@@ -2725,6 +2765,7 @@ class Typer extends Namer
           }
         case _ =>
       }
+
       // try an extension method in scope
       pt match {
         case SelectionProto(name, mbrType, _, _) =>
@@ -2749,6 +2790,7 @@ class Typer extends Namer
           }
         case _ =>
       }
+
       // try an implicit conversion
       val prevConstraint = ctx.typerState.constraint
       def recover(failure: SearchFailureType) =

tests/pos/i2104b.decompiled

@@ -10,7 +10,7 @@ case class Pair[A, B](_1: A, _2: B) {
     acc = scala.runtime.Statics.mix(acc, scala.runtime.Statics.anyHash(Pair.this._2))
     scala.runtime.Statics.finalizeHash(acc, 2)
   }
-  override def equals(x$0: scala.Any): scala.Boolean = Pair.this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
+  override def equals(x$0: scala.Any): scala.Boolean = Pair.this.eq(x$0.$asInstanceOf$[java.lang.Object]).||(x$0 match {
     case x$0: Pair[A, B] @scala.unchecked =>
       Pair.this._1.==(x$0._1).&&(Pair.this._2.==(x$0._2))
     case _ =>

tests/pos/i3598.scala

@@ -1,4 +1,5 @@
 class Foo[A] {
   def baz(foo: Foo[_]): Unit = bar(foo)
+  def bam(foo: => Foo[_]) = bar(foo)
   def bar[A](foo: Foo[A]): A = ???
 }

tests/pos/simpleCaseClass-1.decompiled

@@ -1,6 +1,6 @@
 case class A() {
   override def hashCode(): scala.Int = 1914112431
-  override def equals(x$0: scala.Any): scala.Boolean = A.this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
+  override def equals(x$0: scala.Any): scala.Boolean = A.this.eq(x$0.$asInstanceOf$[java.lang.Object]).||(x$0 match {
     case x$0: A @scala.unchecked =>
       true
     case _ =>

tests/pos/simpleCaseClass-2.decompiled

@@ -4,7 +4,7 @@ case class A(x: scala.Int) {
     acc = scala.runtime.Statics.mix(acc, A.this.x)
     scala.runtime.Statics.finalizeHash(acc, 1)
   }
-  override def equals(x$0: scala.Any): scala.Boolean = A.this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
+  override def equals(x$0: scala.Any): scala.Boolean = A.this.eq(x$0.$asInstanceOf$[java.lang.Object]).||(x$0 match {
     case x$0: A @scala.unchecked =>
       A.this.x.==(x$0.x)
     case _ =>

tests/pos/simpleCaseClass-3.decompiled

@@ -4,7 +4,7 @@ case class A[T](x: T) {
     acc = scala.runtime.Statics.mix(acc, scala.runtime.Statics.anyHash(A.this.x))
     scala.runtime.Statics.finalizeHash(acc, 1)
   }
-  override def equals(x$0: scala.Any): scala.Boolean = A.this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
+  override def equals(x$0: scala.Any): scala.Boolean = A.this.eq(x$0.$asInstanceOf$[java.lang.Object]).||(x$0 match {
     case x$0: A[T] @scala.unchecked =>
       A.this.x.==(x$0.x)
     case _ =>

tests/run/literals.decompiled

@@ -6,7 +6,7 @@ object Test {
       acc = scala.runtime.Statics.mix(acc, GGG.this.i)
       scala.runtime.Statics.finalizeHash(acc, 1)
     }
-    override def equals(x$0: scala.Any): scala.Boolean = GGG.this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
+    override def equals(x$0: scala.Any): scala.Boolean = GGG.this.eq(x$0.$asInstanceOf$[java.lang.Object]).||(x$0 match {
       case x$0: Test.GGG @scala.unchecked =>
         GGG.this.i.==(x$0.i)
       case _ =>