From 48ede0d254ee1ea03a51c4a53fe5e8d6ae3b335d Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 27 Jul 2015 12:22:21 +1000 Subject: Avoid leaking untyped trees out of macro The stack trace and bisection in #119 made me notice that we are failing to typecheck the cast we generated in the fix for #74. The ticket doesn't have a reproduction, so I'm submitting this without a test case. Fixes #119 (cherry picked from commit a037da192dbea32cffa8c5c8d33e7c56af0c353f) --- src/main/scala/scala/async/internal/AnfTransform.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/scala/scala/async/internal/AnfTransform.scala b/src/main/scala/scala/async/internal/AnfTransform.scala index 3c8c837..9bc36d8 100644 --- a/src/main/scala/scala/async/internal/AnfTransform.scala +++ b/src/main/scala/scala/async/internal/AnfTransform.scala @@ -81,7 +81,7 @@ private[async] trait AnfTransform { // TODO avoid creating a ValDef for the result of this await to avoid this tree shape altogether. // This will require some deeper changes to the later parts of the macro which currently assume regular // tree structure around `await` calls. - gen.mkCast(ref, definitions.UnitTpe) + localTyper.typedPos(tree.pos)(gen.mkCast(ref, definitions.UnitTpe)) else ref stats :+ valDef :+ atPos(tree.pos)(ref1) -- cgit v1.2.3 From d74a615334de70c13bd9be00b03b4010de980b0b Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 27 Jul 2015 13:15:43 +1000 Subject: Avoid masking user exception with ??? for Nothing typed expressions Code like: val x = if (cond) throw new A else throw new B Was being transformed to: val ifRes = ??? if (cond) ifRes = throw new A else ifRes = throw new B val x = ifRes by way of the use of `gen.mkZero` which throws `???` if the requested type is `Nothing` This commit special cases `Nothing` typed expressions in a similar manner to `Unit` type expressions. The example above is now translated to: if (cond) throw new A else throw new B val x = throw new IllegalStateException() Fixes #120 (cherry picked from commit 80aaf18d5111322baee73dad30eb0a81cdd62314) --- .../scala/scala/async/internal/AnfTransform.scala | 10 ++++-- .../scala/async/internal/TransformUtils.scala | 2 ++ .../scala/async/run/anf/AnfTransformSpec.scala | 42 ++++++++++++++++++++++ 3 files changed, 52 insertions(+), 2 deletions(-) diff --git a/src/main/scala/scala/async/internal/AnfTransform.scala b/src/main/scala/scala/async/internal/AnfTransform.scala index 9bc36d8..e41c64e 100644 --- a/src/main/scala/scala/async/internal/AnfTransform.scala +++ b/src/main/scala/scala/async/internal/AnfTransform.scala @@ -70,6 +70,9 @@ private[async] trait AnfTransform { val stats :+ expr = anf.transformToList(tree) def statsExprUnit = stats :+ expr :+ localTyper.typedPos(expr.pos)(Literal(Constant(()))) + def statsExprThrow = + stats :+ expr :+ localTyper.typedPos(expr.pos)(Throw(Apply(Select(New(gen.mkAttributedRef(defn.IllegalStateExceptionClass)), nme.CONSTRUCTOR), Nil))) + expr match { case Apply(fun, args) if isAwait(fun) => val valDef = defineVal(name.await, expr, tree.pos) @@ -90,6 +93,8 @@ private[async] trait AnfTransform { // but add Unit value to bring it into form expected by async transform if (expr.tpe =:= definitions.UnitTpe) { statsExprUnit + } else if (expr.tpe =:= definitions.NothingTpe) { + statsExprThrow } else { val varDef = defineVar(name.ifRes, expr.tpe, tree.pos) def branchWithAssign(orig: Tree) = localTyper.typedPos(orig.pos) { @@ -110,8 +115,9 @@ private[async] trait AnfTransform { // but add Unit value to bring it into form expected by async transform if (expr.tpe =:= definitions.UnitTpe) { statsExprUnit - } - else { + } else if (expr.tpe =:= definitions.NothingTpe) { + statsExprThrow + } else { val varDef = defineVar(name.matchRes, expr.tpe, tree.pos) def typedAssign(lhs: Tree) = localTyper.typedPos(lhs.pos)(Assign(Ident(varDef.symbol), mkAttributedCastPreservingAnnotations(lhs, varDef.symbol.tpe))) diff --git a/src/main/scala/scala/async/internal/TransformUtils.scala b/src/main/scala/scala/async/internal/TransformUtils.scala index da76c18..5b5c4d2 100644 --- a/src/main/scala/scala/async/internal/TransformUtils.scala +++ b/src/main/scala/scala/async/internal/TransformUtils.scala @@ -83,6 +83,8 @@ private[async] trait TransformUtils { val NonFatalClass = rootMirror.staticModule("scala.util.control.NonFatal") val Async_await = asyncBase.awaitMethod(global)(macroApplication.symbol).ensuring(_ != NoSymbol) + val IllegalStateExceptionClass = rootMirror.staticClass("java.lang.IllegalStateException") + } def isSafeToInline(tree: Tree) = { diff --git a/src/test/scala/scala/async/run/anf/AnfTransformSpec.scala b/src/test/scala/scala/async/run/anf/AnfTransformSpec.scala index 757ae0b..bbc1b2b 100644 --- a/src/test/scala/scala/async/run/anf/AnfTransformSpec.scala +++ b/src/test/scala/scala/async/run/anf/AnfTransformSpec.scala @@ -405,4 +405,46 @@ class AnfTransformSpec { val applyImplicitView = tree.collect { case x if x.getClass.getName.endsWith("ApplyImplicitView") => x } applyImplicitView.map(_.toString) mustBe List("view(a$1)") } + + @Test + def nothingTypedIf(): Unit = { + import scala.async.internal.AsyncId.{async, await} + val result = util.Try(async { + if (true) { + val n = await(1) + if (n < 2) { + throw new RuntimeException("case a") + } + else { + throw new RuntimeException("case b") + } + } + else { + "case c" + } + }) + + assert(result.asInstanceOf[util.Failure[_]].exception.getMessage == "case a") + } + + @Test + def nothingTypedMatch(): Unit = { + import scala.async.internal.AsyncId.{async, await} + val result = util.Try(async { + 0 match { + case _ if "".isEmpty => + val n = await(1) + n match { + case _ if n < 2 => + throw new RuntimeException("case a") + case _ => + throw new RuntimeException("case b") + } + case _ => + "case c" + } + }) + + assert(result.asInstanceOf[util.Failure[_]].exception.getMessage == "case a") + } } -- cgit v1.2.3