Cleaning up util.Tracer and its usage in Erasure.

2 files changed, 40 insertions, 14 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index ca39ec4a4d..f9f2f94917 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -209,7 +209,7 @@ abstract class Erasure extends AddInterfaces
     !sym.isHigherOrderTypeParameter &&
     sym.isTypeParameterOrSkolem && (
       (initialSymbol.enclClassChain.exists(sym isNestedIn _)) ||
-      traceSig.seq("isMethod", Seq(initialSymbol, initialSymbol.typeParams)) {
+      traceSig("isMethod", (initialSymbol, initialSymbol.typeParams)) {
         (initialSymbol.isMethod && initialSymbol.typeParams.contains(sym))
       }
     )
@@ -229,7 +229,8 @@ abstract class Erasure extends AddInterfaces
     }
   }
   // for debugging signatures: traces logic given system property
-  private val traceSig = util.Tracer(sys.props contains "scalac.sigs.trace")
+  private val traceProp = sys.BooleanProp keyExists "scalac.sigs.trace"
+  private val traceSig  = util.Tracer(traceProp)
 
   /** This object is only used for sanity testing when -check:genjvm is set.
    *  In that case we make sure that the erasure of the `normalized' type
@@ -356,7 +357,7 @@ abstract class Erasure extends AddInterfaces
           }
           else if (sym.isClass) {
             val preRebound = pre.baseType(sym.owner) // #2585
-            traceSig.seq("sym.isClass", Seq(sym.ownerChain, preRebound, sym0.enclClassChain)) {
+            traceSig("sym.isClass", (sym.ownerChain, preRebound, sym0.enclClassChain)) {
               dotCleanup(
                 (
                   if (needsJavaSig(preRebound)) {
@@ -389,7 +390,7 @@ abstract class Erasure extends AddInterfaces
           def paramSig(tsym: Symbol) = tsym.name + boundSig(hiBounds(tsym.info.bounds))
 
           val paramString = if (toplevel) tparams map paramSig mkString ("<", "", ">") else ""
-          traceSig.seq("PolyType", Seq(tparams, restpe))(paramString + jsig(restpe))
+          traceSig("PolyType", (tparams, restpe))(paramString + jsig(restpe))
         case MethodType(params, restpe) =>
           "("+(params map (_.tpe) map (jsig(_))).mkString+")"+
           (if (restpe.typeSymbol == UnitClass || sym0.isConstructor) VOID_TAG.toString else jsig(restpe))
@@ -408,7 +409,7 @@ abstract class Erasure extends AddInterfaces
           else jsig(etp)
       }
     }
-    traceSig.seq("javaSig", Seq(sym0, info)) {
+    traceSig("javaSig", (sym0, info)) {
       if (needsJavaSig(info)) {
         try Some(jsig(info, toplevel = true))
         catch { case ex: UnknownSig => None }
diff --git a/src/compiler/scala/tools/nsc/util/Tracer.scala b/src/compiler/scala/tools/nsc/util/Tracer.scala
index 17be05a4d6..1dd21b26c2 100644
--- a/src/compiler/scala/tools/nsc/util/Tracer.scala
+++ b/src/compiler/scala/tools/nsc/util/Tracer.scala
@@ -6,31 +6,56 @@
 package scala.tools.nsc
 package util
 
+import java.io.PrintStream
+
 class Tracer(enabled: () => Boolean) {
+  def out: PrintStream = System.out
+  def intoString(x: Any): String = "" + x
+  def stringify(x: Any): String = x match {
+    case null                   => "null"
+    case x: TraversableOnce[_]  => x map stringify mkString ", "
+    case x: Product             => stringify(x.productIterator)
+    case x: AnyRef              => intoString(x)
+  }
+
+  private val LBRACE = "{"
+  private val RBRACE = "}"
   private var indentLevel = 0
-  private def ind(s: String) = (" " * (indentLevel*2)) + s
+  private def ind(s: String) = (" " * (indentLevel * 2)) + s
   private def indented[T](body: => T): T = {
     indentLevel += 1
     try body
     finally indentLevel -= 1
   }
   private def p(s: String) = {
-    System.out.print(s)
-    System.out.flush()
+    out.print(s)
+    out.flush()
   }
   private def pin[T](x: T): T = {
     p(ind("" + x))
     x
   }
-  def seq[T](name: String, args: => Seq[Any])(body: => T): T = {
+  def apply[T](name: String, args: => Any)(body: => T): T = {
+    val result = body
     if (enabled()) {
-      p(ind("%s(%s) = {\n".format(name, args mkString ", ")))
-      try indented(pin(body))
-      finally println("\n" + ind("}"))
+      // concise output optimization
+      val boolResult = result match {
+        case x: Boolean => Some(x)
+        case _          => None
+      }
+      p(ind("%s(%s) = %s\n".format(
+        name,
+        stringify(args),
+        boolResult getOrElse LBRACE))
+      )
+      if (boolResult.isEmpty) {
+        indented(pin(result))
+        p("\n" + ind(RBRACE))
+      }
+      result
     }
-    else body
+    else result
   }
-  def apply[T](name: String, args: Any*)(body: => T): T = seq(name, args.toSeq)(body)
 }
 
 object Tracer {