Merge 2.10.x to master (plus a test)

src/main/scala/scala/async/internal/AnfTransform.scala

@@ -51,7 +51,7 @@ private[async] trait AnfTransform {
           expr match {
             case Apply(fun, args) if isAwait(fun) =>
               val valDef = defineVal(name.await, expr, tree.pos)
-              stats :+ valDef :+ gen.mkAttributedStableRef(valDef.symbol).setType(tree.tpe).setPos(tree.pos)
+              stats :+ valDef :+ atPos(tree.pos)(gen.mkAttributedStableRef(valDef.symbol)).setType(tree.tpe)
 
             case If(cond, thenp, elsep) =>
               // if type of if-else is Unit don't introduce assignment,
@@ -68,7 +68,7 @@ private[async] trait AnfTransform {
                   }
                 })
                 val ifWithAssign = treeCopy.If(tree, cond, branchWithAssign(thenp), branchWithAssign(elsep)).setType(definitions.UnitTpe)
-                stats :+ varDef :+ ifWithAssign :+ gen.mkAttributedStableRef(varDef.symbol).setType(tree.tpe).setPos(tree.pos)
+                stats :+ varDef :+ ifWithAssign :+ atPos(tree.pos)(gen.mkAttributedStableRef(varDef.symbol)).setType(tree.tpe)
               }
             case LabelDef(name, params, rhs) =>
               statsExprUnit
@@ -93,7 +93,7 @@ private[async] trait AnfTransform {
                 }
                 val matchWithAssign = treeCopy.Match(tree, scrut, casesWithAssign).setType(definitions.UnitTpe)
                 require(matchWithAssign.tpe != null, matchWithAssign)
-                stats :+ varDef :+ matchWithAssign :+ gen.mkAttributedStableRef(varDef.symbol).setPos(tree.pos).setType(tree.tpe)
+                stats :+ varDef :+ matchWithAssign :+ atPos(tree.pos)(gen.mkAttributedStableRef(varDef.symbol)).setType(tree.tpe)
               }
             case _                   =>
               stats :+ expr
@@ -102,7 +102,7 @@ private[async] trait AnfTransform {
 
         private def defineVar(prefix: String, tp: Type, pos: Position): ValDef = {
           val sym = api.currentOwner.newTermSymbol(name.fresh(prefix), pos, MUTABLE | SYNTHETIC).setInfo(uncheckedBounds(tp))
-          valDef(sym, gen.mkZero(uncheckedBounds(tp))).setType(NoType).setPos(pos)
+          valDef(sym, mkZero(uncheckedBounds(tp))).setType(NoType).setPos(pos)
         }
       }
 
@@ -128,8 +128,7 @@ private[async] trait AnfTransform {
 
       def defineVal(prefix: String, lhs: Tree, pos: Position): ValDef = {
         val sym = api.currentOwner.newTermSymbol(name.fresh(prefix), pos, SYNTHETIC).setInfo(uncheckedBounds(lhs.tpe))
-        lhs.changeOwner(api.currentOwner, sym)
-        valDef(sym, lhs.changeOwner(api.currentOwner, sym)).setType(NoType).setPos(pos)
+        internal.valDef(sym, internal.changeOwner(lhs, api.currentOwner, sym)).setType(NoType).setPos(pos)
       }
 
       object anf {

src/main/scala/scala/async/internal/AsyncTransform.scala

@@ -81,7 +81,7 @@ trait AsyncTransform {
           List(
             asyncBase.nullOut(c.universe)(c.Expr[String](Literal(Constant(fieldSym.name.toString))), c.Expr[Any](Ident(fieldSym))).tree
           ),
-          Assign(gen.mkAttributedStableRef(thisType(fieldSym.owner), fieldSym), gen.mkZero(fieldSym.info))
+          Assign(gen.mkAttributedStableRef(thisType(fieldSym.owner), fieldSym), mkZero(fieldSym.info))
         )
       }
       val asyncState = asyncBlock.asyncStates.find(_.state == state).get

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

@@ -327,6 +327,32 @@ private[async] trait TransformUtils {
     else NoPrefix
   }
 
+  private def derivedValueClassUnbox(cls: Symbol) =
+    (cls.info.decls.find(sym => sym.isMethod && sym.asTerm.isParamAccessor) getOrElse NoSymbol)
+
+  def mkZero(tp: Type): Tree = {
+    if (tp.typeSymbol.asClass.isDerivedValueClass) {
+      val argZero = mkZero(derivedValueClassUnbox(tp.typeSymbol).infoIn(tp).resultType)
+      val baseType = tp.baseType(tp.typeSymbol) // use base type here to dealias / strip phantom "tagged types" etc.
+
+      // By explicitly attributing the types and symbols here, we subvert privacy.
+      // Otherwise, ticket86PrivateValueClass would fail.
+
+      // Approximately:
+      // q"new ${valueClass}[$..targs](argZero)"
+      val target: Tree = gen.mkAttributedSelect(
+        c.typecheck(atMacroPos(
+        New(TypeTree(baseType)))), tp.typeSymbol.asClass.primaryConstructor)
+
+      val zero = gen.mkMethodCall(target, argZero :: Nil)
+
+      // restore the original type which we might otherwise have weakened with `baseType` above
+      gen.mkCast(zero, tp)
+    } else {
+      gen.mkZero(tp)
+    }
+  }
+
   // =====================================
   // Copy/Pasted from Scala 2.10.3. See SI-7694.
   private lazy val UncheckedBoundsClass = {

src/test/scala/scala/async/run/toughtype/ToughType.scala

@@ -239,9 +239,82 @@ class ToughTypeSpec {
     val result = Await.result(f, 5.seconds)
     result mustEqual (new IntWrapper("foo"))
   }
+
+  @Test def ticket86NestedValueClass() {
+    import ExecutionContext.Implicits.global
+
+    val f = async {
+      val a = Future.successful(new IntWrapper("42"))
+      await(await(a).plusStr)
+    }
+    val result = Await.result(f, 5.seconds)
+    result mustEqual "42!"
+  }
+
+  @Test def ticket86MatchedValueClass(): Unit = {
+    import ExecutionContext.Implicits.global
+
+    def doAThing(param: IntWrapper) = Future(None)
+
+    val fut = async {
+      Option(new IntWrapper("value!")) match {
+        case Some(valueHolder) =>
+          await(doAThing(valueHolder))
+        case None =>
+          None
+      }
+    }
+
+    val result = Await.result(fut, 5.seconds)
+    result mustBe None
+  }
+
+  @Test def ticket86MatchedParameterizedValueClass(): Unit = {
+    import ExecutionContext.Implicits.global
+
+    def doAThing(param: ParamWrapper[String]) = Future(None)
+
+    val fut = async {
+      Option(new ParamWrapper("value!")) match {
+        case Some(valueHolder) =>
+          await(doAThing(valueHolder))
+        case None =>
+          None
+      }
+    }
+
+    val result = Await.result(fut, 5.seconds)
+    result mustBe None
+  }
+
+  @Test def ticket86PrivateValueClass(): Unit = {
+    import ExecutionContext.Implicits.global
+
+    def doAThing(param: PrivateWrapper) = Future(None)
+
+    val fut = async {
+      Option(PrivateWrapper.Instance) match {
+        case Some(valueHolder) =>
+          await(doAThing(valueHolder))
+        case None =>
+          None
+      }
+    }
+
+    val result = Await.result(fut, 5.seconds)
+    result mustBe None
+  }
 }
 
-class IntWrapper(val value: String) extends AnyVal
+class IntWrapper(val value: String) extends AnyVal {
+  def plusStr = Future.successful(value + "!")
+}
+class ParamWrapper[T](val value: T) extends AnyVal
+
+class PrivateWrapper private (private val value: String) extends AnyVal
+object PrivateWrapper {
+  def Instance = new PrivateWrapper("")
+}
 
 
 trait A