Improve positions of async-transformed code

Don't position the wrapping try / while trees at the
position of the result expression anymore.

Author: retronym

src/compiler/scala/tools/nsc/transform/async/ExprBuilder.scala

@@ -32,7 +32,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
         case ap @ Apply(i @ Ident(_), Nil) if isCaseLabel(i.symbol) || isMatchEndLabel(i.symbol) =>
           currentTransformState.labelDefStates.get(i.symbol) match {
             case Some(state) =>
-              Block(StateTransitionStyle.UpdateAndContinue.trees(state, new StateSet), typed(literalUnit)).setType(definitions.UnitTpe)
+              Block(StateTransitionStyle.UpdateAndContinue.trees(state, new StateSet), typedCurrentPos(literalUnit)).setType(definitions.UnitTpe)
             case None => ap
           }
         case tree => tree
@@ -60,7 +60,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
       val stats1 = mutable.ListBuffer[Tree]()
       def addNullAssigments(syms: Iterator[Symbol]): Unit = {
         for (fieldSym <- syms) {
-          stats1 += typed(Assign(currentTransformState.memberRef(fieldSym), gen.mkZero(fieldSym.info)))
+          stats1 += typedCurrentPos(Assign(currentTransformState.memberRef(fieldSym), gen.mkZero(fieldSym.info)))
         }
       }
       // Add pre-state null assigments at the beginning.
@@ -148,7 +148,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
         }
 
         allNextStates += nextState
-        stats += typed(Return(literalUnit).setSymbol(currentTransformState.applySym))
+        stats += typedCurrentPos(Return(literalUnit).setSymbol(currentTransformState.applySym))
       }
       if (state == StateAssigner.Terminal) {
         // noop
@@ -462,7 +462,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
         val asyncStatesInit = asyncStates.init // drop the terminal state which has no code.
         val throww          = Throw(Apply(Select(New(Ident(IllegalStateExceptionClass)), IllegalStateExceptionClass_NEW_String), List(gen.mkMethodCall(currentRun.runDefinitions.String_valueOf_Int, stateMemberRef :: Nil))))
         val body            =
-          typed(Match(stateMemberRef,
+          typedBasePos(Match(stateMemberRef,
                       asyncStatesInit.map(_.mkHandlerCaseForState) ++
                         List(CaseDef(Ident(nme.WILDCARD), EmptyTree,
                                      throww))))
@@ -480,7 +480,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
                 )
               ), EmptyTree)
         }
-        typed(LabelDef(transformState.whileLabel, Nil, Block(stateMatch :: Nil, Apply(Ident(transformState.whileLabel), Nil))))
+        typedBasePos  (LabelDef(transformState.whileLabel, Nil, Block(stateMatch :: Nil, Apply(Ident(transformState.whileLabel), Nil))))
       }
 
       private def compactStates = true
@@ -557,7 +557,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
       } else {
         val temp = awaitableResult.symbol.newTermSymbol(nme.trGetResult).setInfo(definitions.ObjectTpe)
         val tempVd = ValDef(temp, gen.mkMethodCall(currentTransformState.memberRef(currentTransformState.stateTryGet), tryyReference :: Nil))
-        typed(Block(
+        typedCurrentPos(Block(
           tempVd :: Nil,
         If(Apply(gen.mkAttributedSelect(currentTransformState.stateMachineRef(), definitions.Object_eq), gen.mkAttributedIdent(temp) :: Nil),
              Return(literalUnit),
@@ -571,7 +571,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
   // Comlete the Promise in the `result` field with the final successful result of this async block.
   private def completeSuccess(expr: Tree): Tree = {
     deriveTree(expr, definitions.UnitTpe) { expr =>
-      typed(Apply(currentTransformState.memberRef(currentTransformState.stateCompleteSuccess), expr :: Nil))
+      typedCurrentPos(Apply(currentTransformState.memberRef(currentTransformState.stateCompleteSuccess), expr :: Nil))
     }
   }
 
@@ -581,7 +581,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
     protected def mkStateTree(nextState: Int): Tree = {
       val transformState = currentTransformState
       val callSetter = Apply(transformState.memberRef(transformState.stateSetter), Literal(Constant(nextState)) :: Nil)
-      typed(callSetter.updateAttachment(StateTransitionTree))
+      typedCurrentPos(callSetter.updateAttachment(StateTransitionTree))
     }
   }
 
@@ -625,9 +625,9 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
             If(Apply(null_ne, Ident(transformState.applyTrParam) :: Nil),
               Apply(Ident(transformState.whileLabel), Nil),
               Block(toStats(callOnComplete(gen.mkAttributedIdent(tempAwaitableSym))), Return(literalUnit).setSymbol(transformState.applySym)))
-          typed(initAwaitableTemp) :: typed(initTempCompleted) :: mkStateTree(nextState) :: typed(ifTree) :: Nil
+          typedCurrentPos(initAwaitableTemp) :: typedCurrentPos(initTempCompleted) :: mkStateTree(nextState) :: typedCurrentPos(ifTree) :: Nil
         } else {
-          mkStateTree(nextState) :: toStats(typed(callOnComplete(awaitable))) ::: typed(Return(literalUnit)) :: Nil
+          mkStateTree(nextState) :: toStats(typedCurrentPos(callOnComplete(awaitable))) ::: typedCurrentPos(Return(literalUnit)) :: Nil
         }
       }
     }
@@ -636,7 +636,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
     case object UpdateAndContinue extends StateTransitionStyle {
       def trees(nextState: Int, stateSet: StateSet): List[Tree] = {
         stateSet += nextState
-        List(mkStateTree(nextState), typed(Apply(Ident(currentTransformState.whileLabel), Nil)))
+        List(mkStateTree(nextState), typedCurrentPos(Apply(Ident(currentTransformState.whileLabel), Nil)))
       }
     }
   }

src/compiler/scala/tools/nsc/transform/async/TransformUtils.scala

@@ -24,7 +24,8 @@ private[async] trait TransformUtils extends AsyncTransformStates {
   private[async] val asyncNames: AsyncNames[global.type]
 
   def typedPos(pos: Position)(tree: Tree): Tree = currentTransformState.localTyper.typedPos(pos)(tree: Tree)
-  def typed(tree: Tree): Tree = typedPos(currentTransformState.currentPos)(tree)
+  def typedCurrentPos(tree: Tree): Tree = typedPos(currentTransformState.currentPos)(tree)
+  def typedBasePos(tree: Tree): Tree = typedPos(currentTransformState.applySym.pos)(tree)
 
   lazy val IllegalStateExceptionClass: Symbol = rootMirror.staticClass("java.lang.IllegalStateException")
   lazy val IllegalStateExceptionClass_NEW_String: Symbol = IllegalStateExceptionClass.info.decl(nme.CONSTRUCTOR).suchThat(

test/junit/scala/tools/nsc/async/AnnotationDrivenAsyncTest.scala

@@ -414,63 +414,7 @@ class AnnotationDrivenAsyncTest {
         val actual = posMap.toList.mkString("\n")
         val expected =
           """(val x = id(1),self.x)
-            |(x.$plus(y),while$(){
-            |  try {
-            |    self.state() match {
-            |      case 0 => {
-            |        val awaitable$async: scala.tools.nsc.async.CustomFuture = scala.tools.nsc.async.CustomFuture._successful(scala.Int.box(Test.this.id(1)));
-            |        tr = self.getCompleted(awaitable$async);
-            |        self.state_=(1);
-            |        if (null.!=(tr))
-            |          while$()
-            |        else
-            |          {
-            |            self.onComplete(awaitable$async);
-            |            return ()
-            |          }
-            |      }
-            |      case 1 => {
-            |        <synthetic> val await$1: Object = {
-            |          val tryGetResult$async: Object = self.tryGet(tr);
-            |          if (self.eq(tryGetResult$async))
-            |            return ()
-            |          else
-            |            tryGetResult$async.$asInstanceOf[Object]()
-            |        };
-            |        self.x = scala.Int.unbox(await$1);
-            |        val awaitable$async: scala.tools.nsc.async.CustomFuture = scala.tools.nsc.async.CustomFuture._successful(scala.Int.box(Test.this.id(2)));
-            |        tr = self.getCompleted(awaitable$async);
-            |        self.state_=(2);
-            |        if (null.!=(tr))
-            |          while$()
-            |        else
-            |          {
-            |            self.onComplete(awaitable$async);
-            |            return ()
-            |          }
-            |      }
-            |      case 2 => {
-            |        <synthetic> val await$2: Object = {
-            |          val tryGetResult$async: Object = self.tryGet(tr);
-            |          if (self.eq(tryGetResult$async))
-            |            return ()
-            |          else
-            |            tryGetResult$async.$asInstanceOf[Object]()
-            |        };
-            |        val y: Int = scala.Int.unbox(await$2);
-            |        self.completeSuccess(scala.Int.box(self.x.+(y)));
-            |        return ()
-            |      }
-            |      case _ => throw new IllegalStateException(java.lang.String.valueOf(self.state()))
-            |    }
-            |  } catch {
-            |    case (throwable$async @ (_: Throwable)) => {
-            |      self.completeFailure(throwable$async);
-            |      return ()
-            |    }
-            |  };
-            |  while$()
-            |})
+            |(x.$plus(y),self.completeSuccess(scala.Int.box(self.x.+(y))))
             |(val y = id(2),val y: Int = scala.Int.unbox(await$2))""".stripMargin
         assertEquals(
           expected, actual)