Workaround ill-scoped exist. skolem refs emited by patmat

e.g `val x2 = Foo[$1] with Bar = boundValue`

is rewritten to `val x2 = (Foo[$1] @uncheckedBounds) with Bar = boundValue`

This is to have refchecks turn a blind eye to the type argument that
doesn't conform the to type parameter bounds.

For regular compilation, without the async transform between patmat
and refchecks, bound conformance is disabled with:

  https://github.com/scala/scala/blob/v2.11.7/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala#L1743

Using the `uncheckedBounds` annotation is a newer, more inclusive way
of acheiving the same thing:

  https://github.com/scala/scala/blob/v2.11.7/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala#L1677

Author: retronym

src/main/scala/scala/async/internal/TransformUtils.scala

@@ -524,11 +524,51 @@ private[async] trait TransformUtils {
               treeCopy.If(tree, cond1, thenp1, elsep1)
           case Apply(fun, args) if isLabel(fun.symbol) =>
             internal.setType(treeCopy.Apply(tree, api.recur(fun), args map api.recur), UnitTpe)
+          case vd @ ValDef(mods, name, tpt, rhs) if isCaseTempVal(vd.symbol) =>
+            def addUncheckedBounds(t: Tree) = {
+              typingTransform(t, owner) {
+                (tree, api) =>
+                  internal.setType(api.default(tree), uncheckedBoundsIfNeeded(tree.tpe))
+              }
+
+            }
+            val uncheckedRhs = addUncheckedBounds(api.recur(rhs))
+            val uncheckedTpt = addUncheckedBounds(tpt)
+            internal.setInfo(vd.symbol, uncheckedBoundsIfNeeded(vd.symbol.info))
+            treeCopy.ValDef(vd, mods, name, uncheckedTpt, uncheckedRhs)
           case t => api.default(t)
         }
     }
   }
 
+  private def isExistentialSkolem(s: Symbol) = {
+    val EXISTENTIAL: Long = 1L << 35
+    internal.isSkolem(s) && (internal.flags(s).asInstanceOf[Long] & EXISTENTIAL) != 0
+  }
+  private def isCaseTempVal(s: Symbol) = {
+    s.isTerm && s.asTerm.isVal && s.isSynthetic && s.name.toString.startsWith("x")
+  }
+
+  def uncheckedBoundsIfNeeded(t: Type): Type = {
+    var quantified: List[Symbol] = Nil
+    var badSkolemRefs: List[Symbol] = Nil
+    t.foreach {
+      case et: ExistentialType =>
+        quantified :::= et.quantified
+      case TypeRef(pre, sym, args) =>
+        val illScopedSkolems = args.map(_.typeSymbol).filter(arg => isExistentialSkolem(arg) && !quantified.contains(arg))
+        badSkolemRefs :::= illScopedSkolems
+      case _ =>
+    }
+    if (badSkolemRefs.isEmpty) t
+    else t.map {
+      case tp @ TypeRef(pre, sym, args) if args.exists(a => badSkolemRefs.contains(a.typeSymbol)) =>
+        uncheckedBounds(tp)
+      case t => t
+    }
+  }
+
+
   final def mkMutableField(tpt: Type, name: TermName, init: Tree): List[Tree] = {
     if (isPastTyper) {
       // If we are running after the typer phase (ie being called from a compiler plugin)

src/test/scala/scala/async/run/late/LateExpansion.scala

@@ -476,7 +476,7 @@ abstract class LatePlugin extends Plugin {
       }
     }
 
-    override val runsAfter: List[String] = "refchecks" :: Nil
+    override val runsAfter: List[String] = "patmat" :: Nil
     override val phaseName: String = "postpatmat"
 
   })