Proliferating the number of debugging modes bec...

Proliferating the number of debugging modes because it's still way
too hard to see what's going on in there. Until we get hubert's type
debugger with its whiz-bang whizbanginess, we'll have to struggle along
with somewhat prettier ascii. This introduces:

  -Yinfer-debug

which tries to print in readable fashion what is happening in the
worlds of inference and implicit search. It should be made a bit more
complementary and less overlappy with -Ytyper-debug. No review.

1 files changed, 8 insertions, 2 deletions

diff --git a/src/compiler/scala/reflect/internal/Trees.scala b/src/compiler/scala/reflect/internal/Trees.scala
index 6d3cc8b8cb..2ee1a59355 100644
--- a/src/compiler/scala/reflect/internal/Trees.scala
+++ b/src/compiler/scala/reflect/internal/Trees.scala
@@ -1507,6 +1507,10 @@ trait Trees /*extends reflect.generic.Trees*/ { self: SymbolTable =>
       if (tree eq orig) super.transform(tree)
       else tree
   }
+  // Create a readable string describing a substitution.
+  private def substituterString(fromStr: String, toStr: String, from: List[Any], to: List[Any]): String = {
+    "subst[%s, %s](%s)".format(fromStr, toStr, (from, to).zipped map (_ + " -> " + _) mkString ", ")
+  }
 
   class TreeSubstituter(from: List[Symbol], to: List[Tree]) extends Transformer {
     override def transform(tree: Tree): Tree = tree match {
@@ -1519,11 +1523,13 @@ trait Trees /*extends reflect.generic.Trees*/ { self: SymbolTable =>
       case _ =>
         super.transform(tree)
     }
+    override def toString = substituterString("Symbol", "Tree", from, to)
   }
 
   class TreeTypeSubstituter(val from: List[Symbol], val to: List[Type]) extends Traverser {
     val typeSubst = new SubstTypeMap(from, to)
     def fromContains = typeSubst.fromContains
+    def isEmpty = from.isEmpty && to.isEmpty
 
     override def traverse(tree: Tree) {
       if (tree.tpe ne null) tree.tpe = typeSubst(tree.tpe)
@@ -1552,7 +1558,7 @@ trait Trees /*extends reflect.generic.Trees*/ { self: SymbolTable =>
       super.traverse(tree)
     }
     override def apply[T <: Tree](tree: T): T = super.apply(tree.duplicate)
-    override def toString() = "TreeSymSubstTraverser("+from+","+to+")"
+    override def toString() = "TreeSymSubstTraverser/" + substituterString("Symbol", "Symbol", from, to)
   }
 
   /** Substitute symbols in 'from' with symbols in 'to'. Returns a new
@@ -1583,7 +1589,7 @@ trait Trees /*extends reflect.generic.Trees*/ { self: SymbolTable =>
         super.transform(tree)
     }
     def apply[T <: Tree](tree: T): T = transform(tree).asInstanceOf[T]
-    override def toString() = "TreeSymSubstituter("+from+","+to+")"
+    override def toString() = "TreeSymSubstituter/" + substituterString("Symbol", "Symbol", from, to)
   }
 
   class ChangeOwnerTraverser(val oldowner: Symbol, val newowner: Symbol) extends Traverser {