Avoid assigning null to vars of derived value type

`TreeGen#mkZero` returns `q"null"` for derived value classes.

```
scala> class V(val a: String) extends AnyVal
defined class V

scala> showRaw(gen.mkZero(typeOf[V]))
res0: String = Literal(Constant(null))
```

We use this API in async to generate the initial value for
ANF-lifted temporary variables.

However, this leads to NPEs, as after posterasure, we call the
unbox method on a null reference:

```
% cat sandbox/Macro.scala; scalac-hash v2.10.4 sandbox/Macro.scala; scala-hash v2.10.4 -e 'val x = Macros.myMacro'
import scala.reflect.macros.Context
import scala.language.experimental.macros

object Macros {
  def macroImpl(c: Context): c.Expr[C] = {
    import c.universe._
    val e1 = c.Expr[C](Literal(Constant(null)).setType(typeOf[C]))
    reify(e1.splice.asInstanceOf[C @annotation.unchecked.uncheckedVariance])
  }

  def myMacro: C = macro macroImpl
}

class C(val a: String) extends AnyVal
java.lang.NullPointerException
	at Main$$anon$1.<init>(scalacmd4059893593754060829.scala:1)
	at Main$.main(scalacmd4059893593754060829.scala:1)
	at Main.main(scalacmd4059893593754060829.scala)
```

This commit installs a custom version of `mkZero` that instead
returns `q"new C[$..targs](${mkZero(wrappedType)})`.

Thanks to @ewiner for pinpointing the problem.

Author: retronym

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

@@ -73,7 +73,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,
@@ -90,7 +90,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
@@ -115,7 +115,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))
             }
           case _                   =>
             stats :+ expr
@@ -124,7 +124,7 @@ private[async] trait AnfTransform {
 
       private def defineVar(prefix: String, tp: Type, pos: Position): ValDef = {
         val sym = currOwner.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)
       }
     }
 
@@ -150,7 +150,6 @@ private[async] trait AnfTransform {
 
     private def defineVal(prefix: String, lhs: Tree, pos: Position): ValDef = {
       val sym = currOwner.newTermSymbol(name.fresh(prefix), pos, SYNTHETIC).setInfo(uncheckedBounds(lhs.tpe))
-      changeOwner(lhs, currentOwner, sym)
       ValDef(sym, changeOwner(lhs, currentOwner, sym)).setType(NoType).setPos(pos)
     }
 
@@ -213,7 +212,7 @@ private[async] trait AnfTransform {
 
             /** The depth of the nested applies: e.g. Apply(Apply(Apply(_, _), _), _)
               *  has depth 3.  Continues through type applications (without counting them.)
-             */
+              */
             def applyDepth: Int = {
               def loop(tree: Tree): Int = tree match {
                 case Apply(fn, _)           => 1 + loop(fn)

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

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

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

@@ -258,6 +258,19 @@ private[async] trait TransformUtils {
     }
   }
 
+  def mkZero(tp: Type): Tree = {
+    if (tp.typeSymbol.isDerivedValueClass) {
+      val argZero = mkZero(tp.memberType(tp.typeSymbol.derivedValueClassUnbox).resultType)
+      val target: Tree = gen.mkAttributedSelect(
+        typer.typedPos(macroPos)(
+        New(TypeTree(tp.baseType(tp.typeSymbol)))), tp.typeSymbol.primaryConstructor)
+      val zero = gen.mkMethodCall(target, argZero :: Nil)
+      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

@@ -228,8 +228,72 @@ class ToughTypeSpec {
       case `e` =>
     }
   }
+
+  @Test def ticket83ValueClass() {
+    import scala.async.Async._
+    import scala.concurrent._, duration._, ExecutionContext.Implicits.global
+    val f = async {
+      val uid = new IntWrapper("foo")
+      await(Future(uid))
+    }
+    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
+  }
 }
 
+class IntWrapper(val value: String) extends AnyVal {
+  def plusStr = Future.successful(value + "!")
+}
+class ParamWrapper[T](val value: T) extends AnyVal
+
+
 trait A
 
 trait B