WIP async positions

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(