From b420446c9f82176e7fe4973576fb2d7f22b28893 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Thu, 25 Sep 2014 18:49:51 -0400 Subject: 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.(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. --- .../scala/scala/async/internal/AnfTransform.scala | 11 ++-- .../scala/async/internal/AsyncTransform.scala | 2 +- .../scala/async/internal/TransformUtils.scala | 13 +++++ .../scala/async/run/toughtype/ToughType.scala | 64 ++++++++++++++++++++++ 4 files changed, 83 insertions(+), 7 deletions(-) (limited to 'src') diff --git a/src/main/scala/scala/async/internal/AnfTransform.scala b/src/main/scala/scala/async/internal/AnfTransform.scala index d879c7b..bf66fde 100644 --- a/src/main/scala/scala/async/internal/AnfTransform.scala +++ b/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) diff --git a/src/main/scala/scala/async/internal/AsyncTransform.scala b/src/main/scala/scala/async/internal/AsyncTransform.scala index a24a823..7d56043 100644 --- a/src/main/scala/scala/async/internal/AsyncTransform.scala +++ b/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 diff --git a/src/main/scala/scala/async/internal/TransformUtils.scala b/src/main/scala/scala/async/internal/TransformUtils.scala index bef52f1..5e73a7f 100644 --- a/src/main/scala/scala/async/internal/TransformUtils.scala +++ b/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 = { diff --git a/src/test/scala/scala/async/run/toughtype/ToughType.scala b/src/test/scala/scala/async/run/toughtype/ToughType.scala index 54a53c8..0f56ae0 100644 --- a/src/test/scala/scala/async/run/toughtype/ToughType.scala +++ b/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 -- cgit v1.2.3