From b8e0e0fa3a4587bf8e15f051daa4254c10a9206e Mon Sep 17 00:00:00 2001
From: phaller <hallerp@gmail.com>
Date: Mon, 12 Nov 2012 16:04:57 +0100
Subject: Reduce visibility of members of ExprBuilder

---
 src/main/scala/scala/async/Async.scala       |  5 ++---
 src/main/scala/scala/async/ExprBuilder.scala | 22 +++++++++++-----------
 2 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/main/scala/scala/async/Async.scala b/src/main/scala/scala/async/Async.scala
index dac35d5..b0ce892 100644
--- a/src/main/scala/scala/async/Async.scala
+++ b/src/main/scala/scala/async/Async.scala
@@ -10,7 +10,6 @@ import scala.collection.mutable.ListBuffer
 import scala.concurrent.{Future, Promise, ExecutionContext, future}
 import ExecutionContext.Implicits.global
 import scala.util.control.NonFatal
-import AsyncUtils.vprintln
 
 
 /*
@@ -82,7 +81,7 @@ abstract class AsyncBase {
 
     val asyncBlockBuilder = new builder.AsyncBlockBuilder(stats, expr, 0, 1000, 1000, Map())
 
-    asyncBlockBuilder.asyncStates foreach (s => vprintln(s))
+    asyncBlockBuilder.asyncStates foreach (s => AsyncUtils.vprintln(s))
 
     val handlerCases: List[CaseDef] = asyncBlockBuilder.mkCombinedHandlerCases[T]()
 
@@ -160,7 +159,7 @@ abstract class AsyncBase {
     // ... and return its Future from the macro.
     val result = futureSystemOps.promiseToFuture(prom)
 
-    vprintln(s"${c.macroApplication} \nexpands to:\n ${result.tree}")
+    AsyncUtils.vprintln(s"${c.macroApplication} \nexpands to:\n ${result.tree}")
 
     result
   }
diff --git a/src/main/scala/scala/async/ExprBuilder.scala b/src/main/scala/scala/async/ExprBuilder.scala
index 56274ec..61a751c 100644
--- a/src/main/scala/scala/async/ExprBuilder.scala
+++ b/src/main/scala/scala/async/ExprBuilder.scala
@@ -14,13 +14,11 @@ import AsyncUtils.vprintln
 final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSystem: FS) {
   builder =>
 
-  lazy val futureSystemOps = futureSystem.mkOps(c)
-
   import c.universe._
   import Flag._
   import defn._
 
-  object name {
+  private[async] object name {
     def suffix(string: String) = string + "$async"
 
     def suffixedName(prefix: String) = newTermName(suffix(prefix))
@@ -38,19 +36,21 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
     def fresh(name: TermName) = newTermName(c.fresh("" + name + "$"))
   }
 
+  private[async] lazy val futureSystemOps = futureSystem.mkOps(c)
+
   private val execContext = futureSystemOps.execContext
 
   private def resetDuplicate(tree: Tree) = c.resetAllAttrs(tree.duplicate)
 
   private def mkResumeApply = Apply(Ident(name.resume), Nil)
 
-  def mkStateTree(nextState: Int): c.Tree =
+  private def mkStateTree(nextState: Int): c.Tree =
     mkStateTree(c.literal(nextState).tree)
 
-  def mkStateTree(nextState: Tree): c.Tree =
+  private def mkStateTree(nextState: Tree): c.Tree =
     Assign(Ident(name.state), nextState)
 
-  def defaultValue(tpe: Type): Literal = {
+  private def defaultValue(tpe: Type): Literal = {
     val defaultValue: Any =
       if (tpe <:< definitions.BooleanTpe) false
       else if (definitions.ScalaNumericValueClasses.exists(tpe <:< _.toType)) 0
@@ -58,14 +58,14 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
     Literal(Constant(defaultValue))
   }
 
-  def mkVarDefTree(resultType: Type, resultName: TermName): c.Tree = {
+  private def mkVarDefTree(resultType: Type, resultName: TermName): c.Tree = {
     ValDef(Modifiers(Flag.MUTABLE), resultName, TypeTree(resultType), defaultValue(resultType))
   }
 
-  def mkHandlerCase(num: Int, rhs: List[c.Tree]): CaseDef =
+  private def mkHandlerCase(num: Int, rhs: List[c.Tree]): CaseDef =
     mkHandlerCase(num, Block(rhs: _*))
 
-  def mkHandlerCase(num: Int, rhs: c.Tree): CaseDef =
+  private def mkHandlerCase(num: Int, rhs: c.Tree): CaseDef =
     CaseDef(c.literal(num).tree, EmptyTree, rhs)
 
   class AsyncState(stats: List[c.Tree], val state: Int, val nextState: Int) {
@@ -403,14 +403,14 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy
   }
 
   /** `termSym( (_: Foo).bar(null: A, null: B)` will return the symbol of `bar`, after overload resolution. */
-  def methodSym(apply: c.Expr[Any]): Symbol = {
+  private def methodSym(apply: c.Expr[Any]): Symbol = {
     val tree2: Tree = c.typeCheck(apply.tree) // TODO why is this needed?
     tree2.collect {
       case s: SymTree if s.symbol.isMethod => s.symbol
     }.headOption.getOrElse(sys.error(s"Unable to find a method symbol in ${apply.tree}"))
   }
 
-  object defn {
+  private[async] object defn {
     def mkList_apply[A](args: List[Expr[A]]): Expr[List[A]] = {
       c.Expr(Apply(Ident(definitions.List_apply), args.map(_.tree)))
     }
-- 
cgit v1.2.3