Fix deprecation warnings newTermName -> TermName

Author: Philippus

src/main/scala/scala/async/internal/AsyncBase.scala

@@ -64,13 +64,13 @@ abstract class AsyncBase {
   protected[async] def asyncMethod(u: Universe)(asyncMacroSymbol: u.Symbol): u.Symbol = {
     import u._
     if (asyncMacroSymbol == null) NoSymbol
-    else asyncMacroSymbol.owner.typeSignature.member(newTermName("async"))
+    else asyncMacroSymbol.owner.typeSignature.member(TermName("async"))
   }
 
   protected[async] def awaitMethod(u: Universe)(asyncMacroSymbol: u.Symbol): u.Symbol = {
     import u._
     if (asyncMacroSymbol == null) NoSymbol
-    else asyncMacroSymbol.owner.typeSignature.member(newTermName("await"))
+    else asyncMacroSymbol.owner.typeSignature.member(TermName("await"))
   }
 
   protected[async] def nullOut(u: Universe)(name: u.Expr[String], v: u.Expr[Any]): u.Expr[Unit] =

src/main/scala/scala/async/internal/AsyncNames.scala

@@ -40,7 +40,7 @@ final class AsyncNames[U <: Names with Singleton](val u: U) {
   }
 
   final class TermNameCache(base: String) extends NameCache[U#TermName](base) {
-    override protected def newName(s: String): U#TermName = newTermName(s)
+    override protected def newName(s: String): U#TermName = TermName(s)
   }
   final class TypeNameCache(base: String) extends NameCache[U#TypeName](base) {
     override protected def newName(s: String): U#TypeName = newTypeName(s)
@@ -49,15 +49,15 @@ final class AsyncNames[U <: Names with Singleton](val u: U) {
   private val ifRes: TermNameCache = new TermNameCache("if")
   private val await: TermNameCache = new TermNameCache("await")
 
-  private val result = newTermName("result$async")
-  private val completed: TermName = newTermName("completed$async")
-  private val apply = newTermName("apply")
-  private val stateMachine  = newTermName("stateMachine$async")
+  private val result = TermName("result$async")
+  private val completed: TermName = TermName("completed$async")
+  private val apply = TermName("apply")
+  private val stateMachine  = TermName("stateMachine$async")
   private val stateMachineT = stateMachine.toTypeName
-  private val state: u.TermName = newTermName("state$async")
-  private val execContext = newTermName("execContext$async")
-  private val tr: u.TermName = newTermName("tr$async")
-  private val t: u.TermName = newTermName("throwable$async")
+  private val state: u.TermName = TermName("state$async")
+  private val execContext = TermName("execContext$async")
+  private val tr: u.TermName = TermName("tr$async")
+  private val t: u.TermName = TermName("throwable$async")
 
   final class NameSource[N <: U#Name](cache: NameCache[N]) {
     private val count = new AtomicInteger(0)

src/main/scala/scala/async/internal/ExprBuilder.scala

@@ -118,7 +118,7 @@ trait ExprBuilder {
     private def tryGetTree(tryReference: => Tree) =
       Assign(
         Ident(awaitable.resultName),
-        TypeApply(Select(futureSystemOps.tryyGet[Any](c.Expr[futureSystem.Tryy[Any]](tryReference)).tree, newTermName("asInstanceOf")), List(TypeTree(awaitable.resultType)))
+        TypeApply(Select(futureSystemOps.tryyGet[Any](c.Expr[futureSystem.Tryy[Any]](tryReference)).tree, TermName("asInstanceOf")), List(TypeTree(awaitable.resultType)))
       )
 
     /* if (tr.isFailure)
@@ -136,7 +136,7 @@ trait ExprBuilder {
           Block(toList(futureSystemOps.completeProm[T](
             c.Expr[futureSystem.Prom[T]](symLookup.memberRef(name.result)),
             c.Expr[futureSystem.Tryy[T]](
-              TypeApply(Select(tryReference, newTermName("asInstanceOf")),
+              TypeApply(Select(tryReference, TermName("asInstanceOf")),
                 List(TypeTree(futureSystemOps.tryType[T]))))).tree),
             Return(literalUnit)),
           getAndUpdateState

src/main/scala/scala/async/internal/TransformUtils.scala

@@ -124,7 +124,7 @@ private[async] trait TransformUtils {
   }
   private lazy val Boolean_ShortCircuits: Set[Symbol] = {
     import definitions.BooleanClass
-    def BooleanTermMember(name: String) = BooleanClass.typeSignature.member(newTermName(name).encodedName)
+    def BooleanTermMember(name: String) = BooleanClass.typeSignature.member(TermName(name).encodedName)
     val Boolean_&& = BooleanTermMember("&&")
     val Boolean_|| = BooleanTermMember("||")
     Set(Boolean_&&, Boolean_||)