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/async/run/toughtype/ToughType.scala | 64 ++++++++++++++++++++++ 1 file changed, 64 insertions(+) (limited to 'src/test/scala/scala/async/run/toughtype/ToughType.scala') 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 From f42efa3b225dc82a83fb1c7730e9218e5c8a0325 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 1 Oct 2014 13:42:07 +1000 Subject: Additional tests and comments around mkZero for value classes --- .../scala/async/internal/TransformUtils.scala | 12 ++++++++++- .../scala/async/run/toughtype/ToughType.scala | 24 ++++++++++++++++++++++ 2 files changed, 35 insertions(+), 1 deletion(-) (limited to 'src/test/scala/scala/async/run/toughtype/ToughType.scala') diff --git a/src/main/scala/scala/async/internal/TransformUtils.scala b/src/main/scala/scala/async/internal/TransformUtils.scala index da70f68..9ae48ed 100644 --- a/src/main/scala/scala/async/internal/TransformUtils.scala +++ b/src/main/scala/scala/async/internal/TransformUtils.scala @@ -333,10 +333,20 @@ private[async] trait TransformUtils { 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(tp.baseType(tp.typeSymbol))))), tp.typeSymbol.asClass.primaryConstructor) + 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) diff --git a/src/test/scala/scala/async/run/toughtype/ToughType.scala b/src/test/scala/scala/async/run/toughtype/ToughType.scala index aedaf10..9ae33b1 100644 --- a/src/test/scala/scala/async/run/toughtype/ToughType.scala +++ b/src/test/scala/scala/async/run/toughtype/ToughType.scala @@ -286,6 +286,24 @@ class ToughTypeSpec { 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 { @@ -293,6 +311,12 @@ class IntWrapper(val value: String) extends AnyVal { } 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 trait B -- cgit v1.2.3