Cleaning up logging in specialization.

3 files changed, 90 insertions, 68 deletions

diff --git a/src/compiler/scala/reflect/internal/SymbolTable.scala b/src/compiler/scala/reflect/internal/SymbolTable.scala
index b58a0ef7d5..bb11ca634a 100644
--- a/src/compiler/scala/reflect/internal/SymbolTable.scala
+++ b/src/compiler/scala/reflect/internal/SymbolTable.scala
@@ -55,6 +55,12 @@ abstract class SymbolTable extends api.Universe
     log(msg + ": " + result)
     result
   }
+  private[scala] def logResultIf[T](msg: String, cond: T => Boolean)(result: T): T = {
+    if (cond(result))
+      log(msg + ": " + result)
+
+    result
+  }
 
   /** Are we compiling for Java SE? */
   // def forJVM: Boolean
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index f4039cf6d3..2019b92836 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -543,7 +543,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     /** Conditions where we omit the prefix when printing a symbol, to avoid
      *  unpleasantries like Predef.String, $iw.$iw.Foo and <empty>.Bippy.
      */
-    final def isOmittablePrefix = !settings.debug.value && (
+    final def isOmittablePrefix = /*!settings.debug.value &&*/ (
          UnqualifiedOwners(skipPackageObject)
       || isEmptyPrefix
     )
@@ -1191,9 +1191,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       var ph = phase
       while (ph.prev.keepsTypeParams)
         ph = ph.prev
-
-      if (ph ne phase)
-        debuglog("checking unsafeTypeParams(" + this + ") at: " + phase + " reading at: " + ph)
+      //
+      // if (ph ne phase)
+      //   debuglog("checking unsafeTypeParams(" + this + ") at: " + phase + " reading at: " + ph)
 
       ph
     }
@@ -2119,7 +2119,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       else ""
 
     def defaultFlagMask =
-      if (settings.debug.value) -1L
+      if (isAbstractType) ExplicitFlags
+      else if (settings.debug.value) -1L
       else if (owner.isRefinementClass) ExplicitFlags & ~OVERRIDE
       else ExplicitFlags
 
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index 7b0f5254b6..185cf4f533 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -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)
-    debuglog("specName(" + sym + ") env: " + env + " tvars: " + tvars)
+    // debuglog("specName(" + sym + ") env: " + env + " tvars: " + tvars)
 
     specializedName(sym.name, methparams map env, others map env)
   }
@@ -518,7 +518,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       // better evaluate it before creating the new class symbol 
       val clazzName = specializedName(clazz, env0).toTypeName
       val bytecodeClazz = clazz.owner.info.decl(clazzName)      
-      debuglog("Specializing " + clazz + " found " + bytecodeClazz + " already there")
+      // debuglog("Specializing " + clazz + ", but found " + bytecodeClazz + " already there")
       bytecodeClazz.info
       
       val sClass = clazz.owner.newClass(clazzName, clazz.pos, (clazz.flags | SPECIALIZED) & ~CASE)
@@ -574,7 +574,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           parents = parents.head.parents.head :: parents
         val extraSpecializedMixins = specializedParents(clazz.info.parents map applyContext)
         if (extraSpecializedMixins.nonEmpty)
-          debuglog("specializeClass on " + clazz + " founds extra specialized mixins: " + extraSpecializedMixins.mkString(", "))
+          debuglog("extra specialized mixins for %s: %s".format(clazz.name.decode, extraSpecializedMixins.mkString(", ")))
         // If the class being specialized has a self-type, the self type may
         // require specialization.  First exclude classes whose self types have
         // the same type constructor as the class itself, since they will
@@ -652,7 +652,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           val NormalizedMember(original) = info(m)
           if (nonConflicting(env ++ typeEnv(m))) {
             if (info(m).degenerate) {
-              debuglog("degenerate normalized member " + m + " info(m): " + info(m))
+              debuglog("degenerate normalized member " + m.defString)
               val specMember = enterMember(cloneInSpecializedClass(m, _ & ~DEFERRED))
 
               info(specMember)    = Implementation(original)
@@ -660,7 +660,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
             }
             else debuglog({
               val om = forwardToOverload(m)
-              "normalizedMember " + m + " om: " + om + " typeEnv(om): " + typeEnv(om)
+              "normalizedMember " + m + " om: " + om + " " + pp(typeEnv(om))
             })
           }
           else
@@ -668,7 +668,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         }
         else if (m.isDeferred) { // abstract methods
           val specMember = enterMember(cloneInSpecializedClass(m, _ | DEFERRED))
-          debuglog("deferred " + specMember.fullName + " remains abstract")
+          // debuglog("deferred " + specMember.fullName + " remains abstract")
 
           info(specMember) = new Abstract(specMember)
           // was: new Forward(specMember) {
@@ -698,20 +698,21 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
 
           enterMember(specVal)
           // create accessors
-          debuglog("m: " + m + " isLocal: " + nme.isLocalName(m.name) + " specVal: " + specVal.name + " isLocal: " + nme.isLocalName(specVal.name))
+          // debuglog("m: " + m + " isLocal: " + nme.isLocalName(m.name) + " specVal: " + specVal.name + " isLocal: " + nme.isLocalName(specVal.name))
+
           if (nme.isLocalName(m.name)) {
             val specGetter = mkAccessor(specVal, nme.localToGetter(specVal.name)) setInfo MethodType(Nil, specVal.info)
             val origGetter = overrideIn(sClass, m.getter(clazz))
             info(origGetter) = Forward(specGetter)
             enterMember(specGetter)
             enterMember(origGetter)
-            debuglog("created accessors: " + specGetter + " orig: " + origGetter)
+            debuglog("specialize accessor in %s: %s -> %s".format(sClass.name.decode, origGetter.name.decode, specGetter.name.decode))
 
             clazz.caseFieldAccessors.find(_.name.startsWith(m.name)) foreach { cfa =>
               val cfaGetter = overrideIn(sClass, cfa)
               info(cfaGetter) = SpecializedAccessor(specVal)
               enterMember(cfaGetter)
-              debuglog("found case field accessor for " + m + " added override " + cfaGetter);
+              debuglog("override case field accessor %s -> %s".format(m.name.decode, cfaGetter.name.decode))
             }
 
             if (specVal.isVariable && m.setter(clazz) != NoSymbol) {
@@ -724,11 +725,15 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
               enterMember(specSetter)
               enterMember(origSetter)
             }
-          } else { // if there are no accessors, specialized methods will need to access this field in specialized subclasses
+          }
+          else { // if there are no accessors, specialized methods will need to access this field in specialized subclasses
             m.resetFlag(PRIVATE)
             specVal.resetFlag(PRIVATE)
+            debuglog("no accessors for %s/%s, specialized methods must access field in subclass".format(
+              m.name.decode, specVal.name.decode))
           }
-        } else if (m.isClass) {
+        }
+        else if (m.isClass) {
           val specClass: Symbol = cloneInSpecializedClass(m, x => x)
           typeEnv(specClass) = fullEnv
           specClass.name = specializedName(specClass, fullEnv).toTypeName
@@ -787,10 +792,10 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
    *     // etc.
    */
   private def normalizeMember(owner: Symbol, sym: Symbol, outerEnv: TypeEnv): List[Symbol] = {
-    debuglog("normalizeMember: " + sym.fullName)
     sym :: (
       if (!sym.isMethod || beforeTyper(sym.typeParams.isEmpty)) Nil
       else {
+        // debuglog("normalizeMember: " + sym.fullNameAsName('.').decode)
         var specializingOn = specializedParams(sym)
         val unusedStvars   = specializingOn filterNot specializedTypeVars(sym.info)
 
@@ -810,7 +815,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           val (keys, vals) = env.toList.unzip
 
           specMember.name = specializedName(sym, env)
-          debuglog("normalizing: " + sym + " to " + specMember + " with params " + tps)
+          // debuglog("%s normalizes to %s%s".format(sym, specMember,
+          //   if (tps.isEmpty) "" else " with params " + tps.mkString(", ")))
 
           typeEnv(specMember) = outerEnv ++ env
           val tps1 = produceTypeParameters(tps, specMember, env)
@@ -820,11 +826,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           val methodType = sym.info.resultType.instantiateTypeParams(keys ++ tps, vals ++ tps1.map(_.tpe)).cloneInfo(specMember)
           specMember setInfo GenPolyType(tps1, methodType)
 
-          debuglog("expanded member: " + sym  + ": " + sym.info +
-            " -> " + specMember +
-            ": " + specMember.info +
-            " env: " + env
-          )
+          debuglog("%s expands to %s in %s".format(sym, specMember.name.decode, pp(env)))
           info(specMember) = NormalizedMember(sym)
           overloads(sym) ::= Overload(specMember, env)
           specMember
@@ -833,6 +835,17 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
     )
   }
 
+  // concise printing of type env
+  private def pp(env: TypeEnv): String = {
+    env.toList.sortBy(_._1.name.toString) map {
+      case (k, v) =>
+        val vsym = v.typeSymbol
+        if (k == vsym) "" + k.name
+        else k.name + ":" + vsym.name
+
+    } mkString ("env(", ", ", ")")
+  }
+
   /** Specialize member `m` w.r.t. to the outer environment and the type
    *  parameters of the innermost enclosing class.
    *
@@ -841,37 +854,38 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
    *  Return a list of symbols that are specializations of 'sym', owned by 'owner'.
    */
   private def specializeMember(owner: Symbol, sym: Symbol, outerEnv: TypeEnv, tps: List[Symbol]): List[Symbol] = {
-    def specializeOn(tparams: List[Symbol]): List[Symbol] =
-      for (spec0 <- specializations(tparams)) yield {
-        val spec = mapAnyRefsInOrigCls(spec0, owner)
-        if (sym.isPrivate/* || sym.isProtected*/) {
-          //sym.privateWithin = sym.enclosingPackage
-          sym.resetFlag(PRIVATE).setFlag(PROTECTED)
-          debuglog("-->d SETTING PRIVATE WITHIN TO " + sym.enclosingPackage + " for " + sym)
-        }
+    def specializeOn(tparams: List[Symbol]): List[Symbol] = specializations(tparams) map { spec0 =>
+      val spec = mapAnyRefsInOrigCls(spec0, owner)
+      if (sym.isPrivate) {
+        sym.resetFlag(PRIVATE).setFlag(PROTECTED)
+        debuglog("Set %s to private[%s]".format(sym, sym.enclosingPackage))
+      }
 
-        val specMember = subst(outerEnv)(specializedOverload(owner, sym, spec))
-        typeEnv(specMember) = typeEnv(sym) ++ outerEnv ++ spec
-        wasSpecializedForTypeVars(specMember) ++= spec collect { case (s, tp) if s.tpe == tp => s }
+      val specMember = subst(outerEnv)(specializedOverload(owner, sym, spec))
+      typeEnv(specMember) = typeEnv(sym) ++ outerEnv ++ spec
+      wasSpecializedForTypeVars(specMember) ++= spec collect { case (s, tp) if s.tpe == tp => s }
 
-        debuglog("sym " + specMember + " was specialized for type vars " + wasSpecializedForTypeVars(specMember))
-        debuglog("added specialized overload: %s in env: %s".format(specMember, typeEnv(specMember)))
+      val wasSpec = wasSpecializedForTypeVars(specMember)
+      if (wasSpec.nonEmpty)
+        debuglog("specialized overload for %s in %s".format(specMember, pp(typeEnv(specMember))))
 
-        overloads(sym) ::= Overload(specMember, spec)
-        specMember
-      }
+      overloads(sym) ::= Overload(specMember, spec)
+      info(specMember) = SpecialOverload(sym, typeEnv(specMember))
+
+      specMember
+    }
 
     if (sym.isMethod) {
-      debuglog("specializeMember %s with tps: %s stvars(sym): %s".format(sym, tps, specializedTypeVars(sym)))
+      val stvars = specializedTypeVars(sym)
+      if (stvars.nonEmpty)
+        debuglog("specialized %s on %s".format(sym.fullLocationString, stvars.map(_.name).mkString(", ")))
 
       val tps1 = if (sym.isConstructor) tps filter (sym.info.paramTypes contains _) else tps
-      val tps2 = tps1 intersect specializedTypeVars(sym).toList
+      val tps2 = tps1 filter stvars
       if (!sym.isDeferred)
         addConcreteSpecMethod(sym)
 
-      val ms = specializeOn(tps2)
-      ms foreach (m => info(m) = SpecialOverload(sym, typeEnv(m)))
-      ms
+      specializeOn(tps2)
     }
     else Nil
   }
@@ -894,7 +908,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
    *
    *  this method will return List('apply$mcII$sp')
    */
-  private def specialOverrides(clazz: Symbol): List[Symbol] = {
+  private def specialOverrides(clazz: Symbol) = logResultIf[List[Symbol]]("specialOverrides(" + clazz + ")", _.nonEmpty) {
     /** Return the overridden symbol in syms that needs a specialized overriding symbol,
      *  together with its specialization environment. The overridden symbol may not be
      *  the closest to 'overriding', in a given hierarchy.
@@ -917,24 +931,21 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       }
       if (!overriding.isParamAccessor) {
         for (overridden <- overriding.allOverriddenSymbols) {
-          debuglog(
-            "Overridden: " + overridden.fullName +
-            ": " + overridden.info +
-            "\n by " + overriding.fullName +
-            ": " + overriding.info
-          )
           val stvars = specializedTypeVars(overridden.info)
           if (stvars.nonEmpty) {
-            debuglog("\t\tspecializedTVars: " + stvars)
+            debuglog("specialized override of %s by %s%s".format(overridden.fullLocationString, overriding.fullLocationString,
+              if (stvars.isEmpty) "" else stvars.map(_.name).mkString("(", ", ", ")")))
+
             if (currentRun compiles overriding)
               checkOverriddenTParams(overridden)
 
             val env    = unify(overridden.info, overriding.info, emptyEnv, false)
             def atNext = afterSpecialize(overridden.owner.info.decl(specializedName(overridden, env)))
 
-            debuglog("\t\tenv: " + env + "isValid: " + TypeEnv.isValid(env, overridden) + "found: " + atNext)
-            if (TypeEnv.restrict(env, stvars).nonEmpty && TypeEnv.isValid(env, overridden) && atNext != NoSymbol)
+            if (TypeEnv.restrict(env, stvars).nonEmpty && TypeEnv.isValid(env, overridden) && atNext != NoSymbol) {
+              debuglog("  " + pp(env) + " found " + atNext)
               return (overridden, env)
+            }
           }
         }
       }
@@ -945,7 +956,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         case (NoSymbol, _)     => None
         case (overridden, env) =>
           val om = specializedOverload(clazz, overridden, env)
-          debuglog("Added specialized overload %s for %s in env: %s with type: %s".format(om, overriding.fullName, env, om.info))
+          debuglog("specialized overload %s for %s in %s: %s".format(om, overriding.name.decode, pp(env), om.info))
           typeEnv(om) = env
           addConcreteSpecMethod(overriding)
           info(om) = (
@@ -993,7 +1004,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
    */
   private def unify(tp1: Type, tp2: Type, env: TypeEnv, strict: Boolean): TypeEnv = (tp1, tp2) match {
     case (TypeRef(_, sym1, _), _) if isSpecialized(sym1) =>
-      debuglog("Unify - basic case: " + tp1 + ", " + tp2)
+      debuglog("Unify " + tp1 + ", " + tp2)
       if (isPrimitiveValueClass(tp2.typeSymbol) || isSpecializedAnyRefSubtype(tp2, sym1))
         env + ((sym1, tp2))
       else if (isSpecializedAnyRefSubtype(tp2, sym1))
@@ -1003,19 +1014,21 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       else
         env
     case (TypeRef(_, sym1, args1), TypeRef(_, sym2, args2)) =>
-      debuglog("Unify TypeRefs: " + tp1 + " and " + tp2 + " with args " + (args1, args2) + " - ")
+      if (args1.nonEmpty || args2.nonEmpty)
+        debuglog("Unify types " + tp1 + " and " + tp2)
+
       if (strict && args1.length != args2.length) unifyError(tp1, tp2)
       val e = unify(args1, args2, env, strict)
-      debuglog("unified to: " + e)
+      if (e.nonEmpty) debuglog("unified to: " + e)
       e
     case (TypeRef(_, sym1, _), _) if sym1.isTypeParameterOrSkolem =>
       env
     case (MethodType(params1, res1), MethodType(params2, res2)) =>
       if (strict && params1.length != params2.length) unifyError(tp1, tp2)
-      debuglog("Unify MethodTypes: " + tp1 + " and " + tp2)
+      debuglog("Unify methods " + tp1 + " and " + tp2)
       unify(res1 :: (params1 map (_.tpe)), res2 :: (params2 map (_.tpe)), env, strict)
     case (PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
-      debuglog("Unify PolyTypes: " + tp1 + " and " + tp2)
+      debuglog("Unify polytypes " + tp1 + " and " + tp2)
       if (strict && tparams1.length != tparams2.length)
         unifyError(tp1, tp2)
       else
@@ -1123,11 +1136,12 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         if (tparams.isEmpty)
           afterSpecialize(parents map (_.typeSymbol.info))
 
-        val parents1 = parents map specializedType
-        debuglog("transformInfo %s %s with parents1 %s ph: %s".format(
-          if (tparams.nonEmpty) " (poly)" else "",
-          clazz, parents1, phase)
-        )
+        val parents1 = parents mapConserve specializedType
+        if (parents ne parents1) {
+          debuglog("specialization transforms %s%s parents to %s".format(
+            if (tparams.nonEmpty) "(poly) " else "", clazz, parents1)
+          )
+        }
         val newScope = newScopeWith(specializeClass(clazz, typeEnv(clazz)) ++ specialOverrides(clazz): _*)
         // If tparams.isEmpty, this is just the ClassInfoType.
         GenPolyType(tparams, ClassInfoType(parents1, newScope, clazz))
@@ -1253,7 +1267,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       override def traverse(tree: Tree) = tree match {
         case DefDef(_, _, _, vparams :: Nil, _, rhs) =>
           if (concreteSpecMethods(tree.symbol) || tree.symbol.isConstructor) {
-            debuglog("!!! adding body of a defdef %s, symbol %s: %s".format(tree, tree.symbol, rhs))
+            // debuglog("!!! adding body of a defdef %s, symbol %s: %s".format(tree, tree.symbol, rhs))
             body(tree.symbol) = rhs
             //          body(tree.symbol) = tree // whole method
             parameters(tree.symbol) = vparams.map(_.symbol)
@@ -1559,7 +1573,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       val env = typeEnv(symbol)
       val boundTvars = env.keySet
       val origtparams = source.typeParams.filter(tparam => !boundTvars(tparam) || !isScalaValueType(env(tparam)))
-      debuglog("substituting " + origtparams + " for " + symbol.typeParams)
+      if (origtparams.nonEmpty || symbol.typeParams.nonEmpty)
+        debuglog("substituting " + origtparams + " for " + symbol.typeParams)
 
       // skolemize type parameters
       val oldtparams = tparams map (_.symbol)
@@ -1656,7 +1671,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
-              debuglog("created synthetic class: " + specCls + " of " + sym1 + " in env: " + env)
+              debuglog("created synthetic class: " + specCls + " of " + sym1 + " in " + pp(env))
             }
           case _ =>
         }