Some logging cleanup.

Quieting things down.  Fixed some things revealed by quieter
logs, like forwarders being generated for superaccessors.

1 files changed, 30 insertions, 40 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index e6567e29f7..e5d1e348d6 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -261,7 +261,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       val stvTypeParams = specializedTypeVars(target.info.typeParams map (_.info))
       val stvResult     = specializedTypeVars(target.info.resultType)
 
-      log("degenerate: " + target + " stv tparams: " + stvTypeParams + " stv info: " + stvResult)
+      debuglog("degenerate: " + target + " stv tparams: " + stvTypeParams + " stv info: " + stvResult)
 
       (stvTypeParams -- stvResult).nonEmpty
     }
@@ -318,7 +318,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       else specializedTypeVars(sym).intersect(env.keySet)
     )
     val (methparams, others) = tvars.toList sortBy ("" + _.name) partition (_.owner.isMethod)
-    log("specName(" + sym + ") env: " + env + " tvars: " + tvars)
+    debuglog("specName(" + sym + ") env: " + env + " tvars: " + tvars)
 
     specializedName(sym.name, methparams map env, others map env)
   }
@@ -572,7 +572,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         // as with the parents and assign it to typeOfThis.
         if (clazz.typeOfThis.typeConstructor ne clazz.typeConstructor) {
           sClass.typeOfThis = applyContext(clazz.typeOfThis)
-          log("Rewriting self-type for specialized class:\n" +
+          debuglog("Rewriting self-type for specialized class:\n" +
               "    " +  clazz.defStringSeenAs(clazz.typeOfThis) + "\n" +
               " => " + sClass.defStringSeenAs(sClass.typeOfThis)
           )
@@ -654,7 +654,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
             })
           }
           else
-            log("conflicting env for " + m + " env: " + env)
+            debuglog("conflicting env for " + m + " env: " + env)
         }
         else if (m.isDeferred) { // abstract methods
           val specMember = enterMember(cloneInSpecializedClass(m, _ | DEFERRED))
@@ -723,7 +723,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           typeEnv(specClass) = fullEnv
           specClass.name = specializedName(specClass, fullEnv).toTypeName
           enterMember(specClass)
-          log("entered specialized class " + specClass.fullName)
+          debuglog("entered specialized class " + specClass.fullName)
           info(specClass) = SpecializedInnerClass(m, fullEnv)
         }
       }
@@ -837,7 +837,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         if (sym.isPrivate/* || sym.isProtected*/) {
           //sym.privateWithin = sym.enclosingPackage
           sym.resetFlag(PRIVATE).setFlag(PROTECTED)
-          log("-->d SETTING PRIVATE WITHIN TO " + sym.enclosingPackage + " for " + sym)
+          debuglog("-->d SETTING PRIVATE WITHIN TO " + sym.enclosingPackage + " for " + sym)
         }
 
         val specMember = subst(outerEnv)(specializedOverload(owner, sym, spec))
@@ -935,7 +935,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         case (NoSymbol, _)     => None
         case (overridden, env) =>
           val om = specializedOverload(clazz, overridden, env)
-          log("Added specialized overload %s for %s in env: %s with type: %s".format(om, overriding.fullName, env, om.info))
+          debuglog("Added specialized overload %s for %s in env: %s with type: %s".format(om, overriding.fullName, env, om.info))
           typeEnv(om) = env
           addConcreteSpecMethod(overriding)
           info(om) = (
@@ -1157,7 +1157,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         if (warnings)
           reporter.warning(tvar.pos, "Bounds prevent specialization of " + tvar)
 
-        log("specvars: " +
+        debuglog("specvars: " +
           tvar.info.bounds.lo + ": " +
           specializedTypeVars(tvar.info.bounds.lo) + " " +
           subst(env, tvar.info.bounds.hi) + ": " +
@@ -1284,7 +1284,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       /** The specialized symbol of 'tree.symbol' for tree.tpe, if there is one */
       def specSym(qual: Tree): Option[Symbol] = {
         val env = unify(symbol.tpe, tree.tpe, emptyEnv, false)
-        log("[specSym] checking for rerouting: %s with \n\tsym.tpe: %s, \n\ttree.tpe: %s \n\tenv: %s \n\tname: %s"
+        debuglog("[specSym] checking for rerouting: %s with \n\tsym.tpe: %s, \n\ttree.tpe: %s \n\tenv: %s \n\tname: %s"
                 .format(tree, symbol.tpe, tree.tpe, env, specializedName(symbol, env)))
         if (!env.isEmpty) {  // a method?
           val specCandidates = qual.tpe.member(specializedName(symbol, env))
@@ -1292,12 +1292,12 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
             doesConform(symbol, tree.tpe, qual.tpe.memberType(s), env)
           }
           
-          log("[specSym] found: " + specCandidates.tpe + ", instantiated as: " + tree.tpe)
-          log("[specSym] found specMember: " + specMember)
+          debuglog("[specSym] found: " + specCandidates.tpe + ", instantiated as: " + tree.tpe)
+          debuglog("[specSym] found specMember: " + specMember)
           if (specMember ne NoSymbol)
             if (TypeEnv.includes(typeEnv(specMember), env)) Some(specMember)
             else {
-              log("wrong environments for specialized member: \n\ttypeEnv(%s) = %s\n\tenv = %s".format(specMember, typeEnv(specMember), env))
+              debuglog("wrong environments for specialized member: \n\ttypeEnv(%s) = %s\n\tenv = %s".format(specMember, typeEnv(specMember), env))
               None
             }
           else None
@@ -1307,11 +1307,11 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       curTree = tree
       tree match {
         case Apply(Select(New(tpt), nme.CONSTRUCTOR), args) =>
-          log("Attempting to specialize new %s(%s)".format(tpt, args.mkString(", ")))
+          debuglog("Attempting to specialize new %s(%s)".format(tpt, args.mkString(", ")))
           val found = findSpec(tpt.tpe)
           if (found.typeSymbol ne tpt.tpe.typeSymbol) {
             // the ctor can be specialized
-            log("** instantiated specialized type: " + found)
+            debuglog("** instantiated specialized type: " + found)
             try localTyper.typedPos(tree.pos)(New(found, transformTrees(args): _*))
             catch {
               case te: TypeError =>
@@ -1340,7 +1340,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
               )
 
               val tree1 = gen.mkTypeApply(Select(qual1, specMember), residualTargs)
-              log("rewrote " + tree + " to " + tree1)
+              debuglog("rewrote " + tree + " to " + tree1)
               localTyper.typedOperator(atPos(tree.pos)(tree1)) // being polymorphic, it must be a method
 
             case None => super.transform(tree)
@@ -1348,8 +1348,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
 
         case Select(Super(_, _), name) if illegalSpecializedInheritance(currentClass) =>
           val pos = tree.pos
-          log(pos.source.file.name+":"+pos.line+": not specializing call to super inside illegal specialized inheritance class.")
-          log(pos.lineContent)
+          debuglog(pos.source.file.name+":"+pos.line+": not specializing call to super inside illegal specialized inheritance class.")
+          debuglog(pos.lineContent)
           tree
 
         case Select(qual, name) =>
@@ -1433,7 +1433,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
               deriveDefDef(tree1)(transform)
 
             case NormalizedMember(target) =>
-              log("Normalized member: " + symbol + ", target: " + target)
+              debuglog("Normalized member: " + symbol + ", target: " + target)
               if (target.isDeferred || conflicting(typeEnv(symbol))) {
                 deriveDefDef(tree)(_ => localTyper typed gen.mkSysErrorCall("Fatal error in code generation: this should never be called."))
               }
@@ -1447,7 +1447,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
             case SpecialOverride(target) =>
               assert(body.isDefinedAt(target), "sym: " + symbol.fullName + " target: " + target.fullName)
               //debuglog("moving implementation, body of target " + target + ": " + body(target))
-              log("%s is param accessor? %b".format(ddef.symbol, ddef.symbol.isParamAccessor))
+              debuglog("%s is param accessor? %b".format(ddef.symbol, ddef.symbol.isParamAccessor))
               // we have an rhs, specialize it
               val tree1 = addBody(ddef, target)
               (new ChangeOwnerTraverser(target, tree1.symbol))(tree1.rhs)
@@ -1456,24 +1456,24 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
 
             case SpecialOverload(original, env) =>
               debuglog("completing specialized " + symbol.fullName + " calling " + original)
-              log("special overload " + original + " -> " + env)
+              debuglog("special overload " + original + " -> " + env)
               val t = DefDef(symbol, { vparamss =>
                 val fun = Apply(Select(This(symbol.owner), original),
                                 makeArguments(original, vparamss.head))
 
-                log("inside defdef: " + symbol + "; type: " + symbol.tpe + "; owner: " + symbol.owner)
+                debuglog("inside defdef: " + symbol + "; type: " + symbol.tpe + "; owner: " + symbol.owner)
                 gen.maybeMkAsInstanceOf(fun,
                   symbol.owner.thisType.memberType(symbol).finalResultType,
                   symbol.owner.thisType.memberType(original).finalResultType)
               })
-              log("created special overload tree " + t)
+              debuglog("created special overload tree " + t)
               debuglog("created " + t)
               localTyper.typed(t)
 
             case fwd @ Forward(_) =>
-              log("forward: " + fwd + ", " + ddef)
+              debuglog("forward: " + fwd + ", " + ddef)
               val rhs1 = forwardCall(tree.pos, gen.mkAttributedRef(symbol.owner.thisType, fwd.target), vparamss)
-              log("-->d completed forwarder to specialized overload: " + fwd.target + ": " + rhs1)
+              debuglog("-->d completed forwarder to specialized overload: " + fwd.target + ": " + rhs1)
               localTyper.typed(deriveDefDef(tree)(_ => rhs1))
 
             case SpecializedAccessor(target) =>
@@ -1481,11 +1481,11 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
                 gen.mkAttributedRef(target)
               else
                 Assign(gen.mkAttributedRef(target), Ident(vparamss.head.head.symbol))
-              log("specialized accessor: " + target + " -> " + rhs1)
+              debuglog("specialized accessor: " + target + " -> " + rhs1)
               localTyper.typed(deriveDefDef(tree)(_ => rhs1))
 
             case Abstract(targ) =>
-              log("abstract: " + targ)
+              debuglog("abstract: " + targ)
               localTyper.typed(deriveDefDef(tree)(rhs => rhs))
           }
 
@@ -1502,17 +1502,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
             symbol.enclClass,
             typeEnv(symbol.alias) ++ typeEnv(tree.symbol)
           )
-          logResult("valdef " + tree + " -> ") {
-            deriveValDef(newValDef)(transform)
-          }
-
-//          val tree1 =
-//            treeCopy.ValDef(tree, mods, name, tpt,
-//              localTyper.typed(
-//                Apply(Select(Super(currentClass, nme.EMPTY), symbol.alias.getter(symbol.alias.owner)),
-//                      List())))
-//          debuglog("replaced ValDef: " + tree1 + " in " + tree.symbol.owner.fullName)
-//          tree1
+          deriveValDef(newValDef)(transform)
 
         case Apply(sel @ Select(sup @ Super(qual, name), name1), args)
           if (sup.symbol.info.parents != atPhase(phase.prev)(sup.symbol.info.parents)) =>
@@ -1535,7 +1525,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       val meth   = addBody(tree, source)
 
       val d = new Duplicator
-      log("-->d DUPLICATING: " + meth)
+      debuglog("-->d DUPLICATING: " + meth)
       d.retyped(
         localTyper.context1.asInstanceOf[d.Context],
         meth,
@@ -1600,7 +1590,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
              if m.hasFlag(SPECIALIZED)
                  && (m.sourceFile ne null)
                  && satisfiable(typeEnv(m), !sClass.hasFlag(SPECIALIZED))) {
-        log("creating tree for " + m.fullName)
+        debuglog("creating tree for " + m.fullName)
         if (m.isMethod)  {
           if (info(m).target.hasAccessorFlag) hasSpecializedFields = true
           if (m.isClassConstructor) {
@@ -1656,7 +1646,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
               buf +=
                 ClassDef(specCls, atPos(impl.pos)(Template(parents, emptyValDef, List()))
                            .setSymbol(specCls.newLocalDummy(sym1.pos))) setPos tree.pos
-              log("created synthetic class: " + specCls + " of " + sym1 + " in env: " + env)
+              debuglog("created synthetic class: " + specCls + " of " + sym1 + " in env: " + env)
             }
           case _ =>
         }