Since trunk seems to be undergoing all kinds of...

Since trunk seems to be undergoing all kinds of changes of the sort
which touch lots of files, the time is ripe for various search/replace
improvements which have stacked up. This one is the replacement of all
"if (settings.debug.value) log" with "debuglog" since as noted in a
recent commit, the inliner will take care of that for you. No review.

27 files changed, 124 insertions, 185 deletions

diff --git a/src/compiler/scala/reflect/internal/SymbolTable.scala b/src/compiler/scala/reflect/internal/SymbolTable.scala
index 81c4cef4d4..9e59c1d509 100644
--- a/src/compiler/scala/reflect/internal/SymbolTable.scala
+++ b/src/compiler/scala/reflect/internal/SymbolTable.scala
@@ -32,6 +32,9 @@ abstract class SymbolTable extends api.Universe
   def abort(msg: String): Nothing = throw new Error(msg)
   def abort(): Nothing = throw new Error()
 
+  /** Override with final implementation for inlining. */
+  def debuglog(msg: => String): Unit = if (settings.debug.value) log(msg)
+
   /** Are we compiling for Java SE? */
   // def forJVM: Boolean
 
@@ -119,7 +122,6 @@ abstract class SymbolTable extends api.Universe
     import scala.tools.util.Signallable
     import scala.runtime.ScalaRunTime.stringOf
 
-
     // We can allow ourselves a structural type, these methods
     // amount to a few calls per run at most.  This does suggest
     // a "Clearable" trait may be useful.
diff --git a/src/compiler/scala/reflect/internal/TreeGen.scala b/src/compiler/scala/reflect/internal/TreeGen.scala
index c17ab8be63..f184bcee51 100644
--- a/src/compiler/scala/reflect/internal/TreeGen.scala
+++ b/src/compiler/scala/reflect/internal/TreeGen.scala
@@ -150,7 +150,7 @@ abstract class TreeGen {
 
   /** Cast `tree` to type `pt` */
   def mkCast(tree: Tree, pt: Type): Tree = {
-    if (settings.debug.value) log("casting " + tree + ":" + tree.tpe + " to " + pt)
+    debuglog("casting " + tree + ":" + tree.tpe + " to " + pt)
     assert(!tree.tpe.isInstanceOf[MethodType], tree)
     assert(!pt.typeSymbol.isPackageClass)
     assert(!pt.typeSymbol.isPackageObjectClass)
diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index 358258390f..2c626013b3 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -4034,14 +4034,13 @@ A type's typeSymbol should never be inspected directly.
         def corresponds(sym1: Symbol, sym2: Symbol): Boolean =
           sym1.name == sym2.name && (sym1.isPackageClass || corresponds(sym1.owner, sym2.owner))
         if (!corresponds(sym.owner, rebind0.owner)) {
-          if (settings.debug.value)
-            log("ADAPT1 pre = "+pre+", sym = "+sym+sym.locationString+", rebind = "+rebind0+rebind0.locationString)
+          debuglog("ADAPT1 pre = "+pre+", sym = "+sym+sym.locationString+", rebind = "+rebind0+rebind0.locationString)
           val bcs = pre.baseClasses.dropWhile(bc => !corresponds(bc, sym.owner));
           if (bcs.isEmpty)
             assert(pre.typeSymbol.isRefinementClass, pre) // if pre is a refinementclass it might be a structural type => OK to leave it in.
           else
             rebind0 = pre.baseType(bcs.head).member(sym.name)
-          if (settings.debug.value) log(
+          debuglog(
             "ADAPT2 pre = " + pre +
             ", bcs.head = " + bcs.head +
             ", sym = " + sym+sym.locationString +
@@ -4053,7 +4052,7 @@ A type's typeSymbol should never be inspected directly.
         }
         val rebind = rebind0.suchThat(sym => sym.isType || sym.isStable)
         if (rebind == NoSymbol) {
-          if (settings.debug.value) log("" + phase + " " +phase.flatClasses+sym.owner+sym.name+" "+sym.isType)
+          debuglog("" + phase + " " +phase.flatClasses+sym.owner+sym.name+" "+sym.isType)
           throw new MalformedType(pre, sym.nameString)
         }
         rebind
@@ -5684,7 +5683,7 @@ A type's typeSymbol should never be inspected directly.
    *  of types.
    */
   private def commonOwner(tps: List[Type]): Symbol = {
-    // if (settings.debug.value) log("computing common owner of types " + tps)//DEBUG
+    // debuglog("computing common owner of types " + tps)//DEBUG
     commonOwnerMap.init
     tps foreach { tp => commonOwnerMap.apply(tp); () }
     commonOwnerMap.result
@@ -5748,7 +5747,7 @@ A type's typeSymbol should never be inspected directly.
         case ex: MalformedType => None
         case ex: IndexOutOfBoundsException =>  // transpose freaked out because of irregular argss
         // catching just in case (shouldn't happen, but also doesn't cost us)
-        if (settings.debug.value) log("transposed irregular matrix!?"+ (tps, argss))
+        debuglog("transposed irregular matrix!?"+ (tps, argss))
         None
       }
     case SingleType(_, sym) :: rest =>
@@ -5770,7 +5769,7 @@ A type's typeSymbol should never be inspected directly.
    */
   def addMember(thistp: Type, tp: Type, sym: Symbol) {
     assert(sym != NoSymbol)
-    // if (settings.debug.value) log("add member " + sym+":"+sym.info+" to "+thistp) //DEBUG
+    // debuglog("add member " + sym+":"+sym.info+" to "+thistp) //DEBUG
     if (!(thistp specializes sym)) {
       if (sym.isTerm)
         for (alt <- tp.nonPrivateDecl(sym.name).alternatives)
@@ -5909,7 +5908,7 @@ A type's typeSymbol should never be inspected directly.
             if (!(declaredBoundsInst <:< argumentBounds))
               stricterBound(hkarg, hkparam)
 
-            if (settings.debug.value) log(
+            debuglog(
               "checkKindBoundsHK base case: " + hkparam +
               " declared bounds: " + declaredBounds +
               " after instantiating earlier hkparams: " + declaredBoundsInst + "\n" +
@@ -5918,8 +5917,7 @@ A type's typeSymbol should never be inspected directly.
             )
           }
           else {
-            if (settings.debug.value)
-              log("checkKindBoundsHK recursing to compare params of "+ hkparam +" with "+ hkarg)
+            debuglog("checkKindBoundsHK recursing to compare params of "+ hkparam +" with "+ hkarg)
             val (am, vm, sb) = checkKindBoundsHK(
               hkarg.typeParams,
               hkarg,
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 5847563a63..2845ee8e03 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -167,7 +167,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
     if (settings.debug.value)
       body
   }
-  @inline final def debuglog(msg: => String) {
+  @inline final override def debuglog(msg: => String) {
     if (settings.debug.value && (settings.log containsPhase globalPhase))
       inform("[log " + phase + "] " + msg)
   }
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
index 63ea572e2f..66acb8e4fe 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
@@ -529,7 +529,7 @@ abstract class CopyPropagation {
       var values = in.stack.take(1 + ctor.info.paramTypes.length).reverse.drop(1);
       val bindings = mutable.HashMap[Symbol, Value]()
 
-      if (settings.debug.value) log("getBindings for: " + ctor + " acc: " + paramAccessors)
+      debuglog("getBindings for: " + ctor + " acc: " + paramAccessors)
 
       var paramTypes = ctor.tpe.paramTypes
       val diff = paramTypes.length - paramAccessors.length
@@ -556,7 +556,7 @@ abstract class CopyPropagation {
         values = values.tail;
       }
 
-      if (settings.debug.value) log("\t" + bindings)
+      debuglog("\t" + bindings)
       bindings
     }
 
diff --git a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
index f2f5ecb2fe..84f73223d5 100644
--- a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
+++ b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
@@ -279,8 +279,7 @@ abstract class GenMSIL extends SubComponent {
 
 
     /*
-      if (settings.debug.value)
-        log("creating annotations: " + annotations + " for member : " + member)
+      debuglog("creating annotations: " + annotations + " for member : " + member)
       for (annot@ AnnotationInfo(typ, annArgs, nvPairs) <- annotations ;
            if annot.isConstant)
            //!typ.typeSymbol.isJavaDefined
@@ -452,8 +451,7 @@ abstract class GenMSIL extends SubComponent {
         val iclass   = classes(sym)
         val tBuilder = types(sym).asInstanceOf[TypeBuilder]
 
-        if (settings.debug.value)
-          log("Calling CreatType for " + sym + ", " + tBuilder.toString)
+        debuglog("Calling CreatType for " + sym + ", " + tBuilder.toString)
 
         tBuilder.CreateType()
         tBuilder.setSourceFilepath(iclass.cunit.source.file.path)
@@ -467,8 +465,7 @@ abstract class GenMSIL extends SubComponent {
 
     private[GenMSIL] def genClass(iclass: IClass) {
       val sym = iclass.symbol
-      if (settings.debug.value)
-        log("Generating class " + sym + " flags: " + Flags.flagsToString(sym.flags))
+      debuglog("Generating class " + sym + " flags: " + Flags.flagsToString(sym.flags))
       clasz = iclass
 
       val tBuilder = getType(sym).asInstanceOf[TypeBuilder]
@@ -480,8 +477,7 @@ abstract class GenMSIL extends SubComponent {
           !((m.symbol.name.toString() != "clone" || m.symbol.name.toString() != "Clone") &&
             m.symbol.tpe.paramTypes.length != 0)
         })) {
-          if (settings.debug.value)
-            log("auto-generating cloneable method for " + sym)
+          debuglog("auto-generating cloneable method for " + sym)
           val attrs: Short = (MethodAttributes.Public | MethodAttributes.Virtual |
                               MethodAttributes.HideBySig).toShort
           val cloneMethod = tBuilder.DefineMethod("Clone", attrs, MOBJECT,
@@ -514,8 +510,7 @@ abstract class GenMSIL extends SubComponent {
 
 
     private def genMethod(m: IMethod) {
-      if (settings.debug.value)
-        log("Generating method " + m.symbol + " flags: " + Flags.flagsToString(m.symbol.flags) +
+      debuglog("Generating method " + m.symbol + " flags: " + Flags.flagsToString(m.symbol.flags) +
             " owner: " + m.symbol.owner)
       method = m
       localBuilders.clear
@@ -544,8 +539,7 @@ abstract class GenMSIL extends SubComponent {
 
       if (mcode != null) {
         for (local <- m.locals ; if !(m.params contains local)) {
-          if (settings.debug.value)
-            log("add local var: " + local + ", of kind " + local.kind)
+          debuglog("add local var: " + local + ", of kind " + local.kind)
           val t: MsilType = msilType(local.kind)
           val localBuilder = mcode.DeclareLocal(t)
           localBuilder.SetLocalSymInfo(msilName(local.sym))
@@ -571,8 +565,7 @@ abstract class GenMSIL extends SubComponent {
     def genCode(m: IMethod) {
 
       def makeLabels(blocks: List[BasicBlock]) = {
-        if (settings.debug.value)
-          log("Making labels for: " + method)
+        debuglog("Making labels for: " + method)
         for (bb <- blocks) labels(bb) = mcode.DefineLabel()
       }
 
@@ -818,8 +811,7 @@ abstract class GenMSIL extends SubComponent {
     def genBlock(block: BasicBlock, prev: BasicBlock, next: BasicBlock) {
 
       def loadLocalOrAddress(local: Local, msg : String , loadAddr : Boolean) {
-        if (settings.debug.value)
-          log(msg + " for " + local)
+        debuglog(msg + " for " + local)
         val isArg = local.arg
         val i = local.index
         if (isArg)
@@ -829,8 +821,7 @@ abstract class GenMSIL extends SubComponent {
       }
 
       def loadFieldOrAddress(field: Symbol, isStatic: Boolean, msg: String, loadAddr : Boolean) {
-        if (settings.debug.value)
-          log(msg + " with owner: " + field.owner +
+        debuglog(msg + " with owner: " + field.owner +
               " flags: " + Flags.flagsToString(field.owner.flags))
         var fieldInfo = fields.get(field) match {
           case Some(fInfo) => fInfo
@@ -916,8 +907,7 @@ abstract class GenMSIL extends SubComponent {
       }
 
       mcode.MarkLabel(labels(block))
-      if (settings.debug.value)
-        log("Generating code for block: " + block)
+      debuglog("Generating code for block: " + block)
 
       for (handler <- beginCatchBlock.get(block)) {
         if (!currentHandlers.isEmpty && currentHandlers.top.covered == handler.covered) {
@@ -1017,8 +1007,7 @@ abstract class GenMSIL extends SubComponent {
             mcode.Emit(OpCodes.Newobj, constructorInfo)
 
           case LOAD_MODULE(module) =>
-            if (settings.debug.value)
-              log("Generating LOAD_MODULE for: " + showsym(module))
+            debuglog("Generating LOAD_MODULE for: " + showsym(module))
             mcode.Emit(OpCodes.Ldsfld, getModuleInstanceField(module))
 
           case STORE_ARRAY_ITEM(kind) =>
@@ -1040,8 +1029,7 @@ abstract class GenMSIL extends SubComponent {
           case STORE_LOCAL(local) =>
             val isArg = local.arg
             val i = local.index
-            if (settings.debug.value)
-              log("store_local for " + local + ", index " + i)
+            debuglog("store_local for " + local + ", index " + i)
 
             // there are some locals defined by the compiler that
             // are isArg and are need to be stored.
@@ -1371,8 +1359,7 @@ abstract class GenMSIL extends SubComponent {
         }
 
         case Conversion(src, dst) =>
-          if (settings.debug.value)
-            log("Converting from: " + src + " to: " + dst)
+          debuglog("Converting from: " + src + " to: " + dst)
 
           dst match {
             case BYTE =>   mcode.Emit(OpCodes.Conv_I1) // I1 for System.SByte, i.e. a scala.Byte
@@ -1586,8 +1573,7 @@ abstract class GenMSIL extends SubComponent {
 
       val params = m.params
       for (l <- params) {
-        if (settings.debug.value)
-          log("Index value for parameter " + l + ": " + idx)
+        debuglog("Index value for parameter " + l + ": " + idx)
         l.index = idx
         idx += 1 // sizeOf(l.kind)
       }
@@ -1596,8 +1582,7 @@ abstract class GenMSIL extends SubComponent {
       idx = 0
 
       for (l <- locvars) {
-        if (settings.debug.value)
-          log("Index value for local variable " + l + ": " + idx)
+        debuglog("Index value for local variable " + l + ": " + idx)
         l.index = idx
         idx += 1 // sizeOf(l.kind)
       }
@@ -1856,8 +1841,7 @@ abstract class GenMSIL extends SubComponent {
         else sym.info.parents.distinct
 
       val superType : MsilType = if (isInterface(sym)) null else msilTypeFromSym(parents.head.typeSymbol)
-      if (settings.debug.value)
-        log("super type: " + parents(0).typeSymbol + ", msil type: " + superType)
+      debuglog("super type: " + parents(0).typeSymbol + ", msil type: " + superType)
 
       val interfaces: Array[MsilType] =
 	parents.tail.map(p => msilTypeFromSym(p.typeSymbol)).toArray
@@ -1897,8 +1881,7 @@ abstract class GenMSIL extends SubComponent {
 
       for (ifield <- iclass.fields) {
         val sym = ifield.symbol
-        if (settings.debug.value)
-          log("Adding field: " + sym.fullName)
+        debuglog("Adding field: " + sym.fullName)
 
         var attributes = msilFieldFlags(sym)
         val fieldTypeWithCustomMods =
@@ -1929,8 +1912,7 @@ abstract class GenMSIL extends SubComponent {
       if (iclass.symbol != definitions.ArrayClass) {
       for (m: IMethod <- iclass.methods) {
         val sym = m.symbol
-        if (settings.debug.value)
-          log("Creating MethodBuilder for " + Flags.flagsToString(sym.flags) + " " +
+        debuglog("Creating MethodBuilder for " + Flags.flagsToString(sym.flags) + " " +
               sym.owner.fullName + "::" + sym.name)
 
         val ownerType = getType(sym.enclClass).asInstanceOf[TypeBuilder]
@@ -1956,8 +1938,7 @@ abstract class GenMSIL extends SubComponent {
           if (!methods.contains(sym))
             mapMethod(sym, method)
           addAttributes(method, sym.annotations)
-          if (settings.debug.value)
-            log("\t created MethodBuilder " + method)
+          debuglog("\t created MethodBuilder " + method)
         }
       }
       } // method builders created for non-array iclass
@@ -1994,8 +1975,7 @@ abstract class GenMSIL extends SubComponent {
     }
 
     private def addModuleInstanceField(sym: Symbol) {
-      if (settings.debug.value)
-        log("Adding Module-Instance Field for " + showsym(sym))
+      debuglog("Adding Module-Instance Field for " + showsym(sym))
       val tBuilder = getType(sym).asInstanceOf[TypeBuilder]
       val fb = tBuilder.DefineField(MODULE_INSTANCE_NAME,
                            tBuilder,
@@ -2071,8 +2051,7 @@ abstract class GenMSIL extends SubComponent {
     private def dumpMirrorClass(sym: Symbol) {
       val tBuilder = getType(sym)
       assert(sym.isModuleClass, "Can't generate Mirror-Class for the Non-Module class " + sym)
-      if (settings.debug.value)
-        log("Dumping mirror class for object: " + sym)
+      debuglog("Dumping mirror class for object: " + sym)
       val moduleName = msilName(sym)
       val mirrorName = moduleName.substring(0, moduleName.length() - 1)
       val mirrorTypeBuilder = mmodule.DefineType(mirrorName,
@@ -2089,8 +2068,7 @@ abstract class GenMSIL extends SubComponent {
            m.isMethod && !m.isClassConstructor && !m.isStaticMember && !m.isCase &&
            !m.isDeferred)
         {
-          if (settings.debug.value)
-            log("   Mirroring method: " + m)
+          debuglog("   Mirroring method: " + m)
           val paramTypes = msilParamTypes(m)
           val paramNames: Array[String] = new Array[String](paramTypes.length)
           for (i <- 0 until paramTypes.length)
diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
index d5194346c9..e0d51aee16 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
@@ -101,7 +101,7 @@ abstract class ClosureElimination extends SubComponent {
 
       for (bb <- linearizer.linearize(m)) {
         var info = cpp.in(bb)
-        if (settings.debug.value) log("Cpp info at entry to block " + bb + ": " + info)
+        debuglog("Cpp info at entry to block " + bb + ": " + info)
 
         for (i <- bb) {
           i match {
diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
index c591fee502..68e0a76a78 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
@@ -136,8 +136,7 @@ abstract class DeadCodeElimination extends SubComponent {
       while (!worklist.isEmpty) {
         val (bb, idx) = worklist.iterator.next
         worklist -= ((bb, idx))
-        if (settings.debug.value)
-          log("Marking instr: \tBB_" + bb + ": " + idx + " " + bb(idx))
+        debuglog("Marking instr: \tBB_" + bb + ": " + idx + " " + bb(idx))
 
         val instr = bb(idx)
         if (!useful(bb)(idx)) {
@@ -211,7 +210,7 @@ abstract class DeadCodeElimination extends SubComponent {
                 log("skipped object creation: " + sym + "inside " + m)
               case _ => ()
             }
-            if (settings.debug.value) log("Skipped: bb_" + bb + ": " + idx + "( " + i + ")")
+            debuglog("Skipped: bb_" + bb + ": " + idx + "( " + i + ")")
           }
         }
 
diff --git a/src/compiler/scala/tools/nsc/matching/Matrix.scala b/src/compiler/scala/tools/nsc/matching/Matrix.scala
index e5b0de6040..61864f0c8a 100644
--- a/src/compiler/scala/tools/nsc/matching/Matrix.scala
+++ b/src/compiler/scala/tools/nsc/matching/Matrix.scala
@@ -122,8 +122,7 @@ trait Matrix extends MatrixAdditions {
     private val _syntheticSyms = mutable.HashSet[Symbol]()
     def clearSyntheticSyms() = {
       _syntheticSyms foreach (_ resetFlag (NO_EXHAUSTIVE|MUTABLE))
-      if (settings.debug.value)
-        log("Cleared NO_EXHAUSTIVE/MUTABLE on " + _syntheticSyms.size + " synthetic symbols.")
+      debuglog("Cleared NO_EXHAUSTIVE/MUTABLE on " + _syntheticSyms.size + " synthetic symbols.")
       _syntheticSyms.clear()
     }
     def recordSyntheticSym(sym: Symbol): Symbol = {
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index 1970a580a6..f121571d17 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -225,11 +225,9 @@ abstract class ClassfileParser {
             first != CONSTANT_METHODREF &&
             first != CONSTANT_INTFMETHODREF) errorBadTag(start)
         val ownerTpe = getClassOrArrayType(in.getChar(start + 1))
-        if (settings.debug.value)
-          log("getMemberSymbol(static: " + static + "): owner type: " + ownerTpe + " " + ownerTpe.typeSymbol.originalName)
+        debuglog("getMemberSymbol(static: " + static + "): owner type: " + ownerTpe + " " + ownerTpe.typeSymbol.originalName)
         val (name0, tpe0) = getNameAndType(in.getChar(start + 3), ownerTpe)
-        if (settings.debug.value)
-          log("getMemberSymbol: name and tpe: " + name0 + ": " + tpe0)
+        debuglog("getMemberSymbol: name and tpe: " + name0 + ": " + tpe0)
 
         forceMangledName(tpe0.typeSymbol.name, false)
         val (name, tpe) = getNameAndType(in.getChar(start + 3), ownerTpe)
@@ -904,8 +902,7 @@ abstract class ClassfileParser {
           else println("failure to convert " + c + " to " + symtype); //debug
         case tpnme.ScalaSignatureATTR =>
           if (!isScalaAnnot) {
-            if (settings.debug.value)
-              log("warning: symbol " + sym.fullName + " has pickled signature in attribute")
+            debuglog("warning: symbol " + sym.fullName + " has pickled signature in attribute")
             unpickler.unpickle(in.buf, in.bp, clazz, staticModule, in.file.toString())
           }
           in.skip(attrLen)
@@ -932,8 +929,7 @@ abstract class ClassfileParser {
                 case None =>
                   throw new RuntimeException("Scala class file does not contain Scala annotation")
               }
-            if (settings.debug.value)
-              log("" + sym + "; annotations = " + sym.rawAnnotations)
+            debuglog("" + sym + "; annotations = " + sym.rawAnnotations)
           } else
             in.skip(attrLen)
 
@@ -1049,8 +1045,7 @@ abstract class ClassfileParser {
     } catch {
       case f: FatalError => throw f // don't eat fatal errors, they mean a class was not found
       case ex: Throwable =>
-        if (settings.debug.value)
-          log("dropping annotation on " + sym + ", an error occured during parsing (e.g. annotation  class not found)")
+        debuglog("dropping annotation on " + sym + ", an error occured during parsing (e.g. annotation  class not found)")
 
         None // ignore malformed annotations ==> t1135
     }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
index b9e8abe53f..94a67bf375 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
@@ -160,13 +160,13 @@ abstract class ICodeReader extends ClassfileParser {
         val attributeCount = in.nextChar
         for (i <- 0 until attributeCount) parseAttribute()
       } else {
-        if (settings.debug.value) log("Skipping non-existent method.");
+        debuglog("Skipping non-existent method.");
         skipAttributes();
       }
     } catch {
       case e: MissingRequirementError =>
         in.bp = beginning; skipAttributes
-        if (settings.debug.value) log("Skipping non-existent method. " + e.msg);
+        debuglog("Skipping non-existent method. " + e.msg);
     }
   }
 
@@ -932,7 +932,7 @@ abstract class ICodeReader extends ClassfileParser {
         for ((i, idx) <- bb.toList.zipWithIndex) i match {
           case CALL_METHOD(m, Static(true)) if m.isClassConstructor =>
             val defs = rdef.findDefs(bb, idx, 1, m.info.paramTypes.length)
-            if (settings.debug.value) log("ctor: " + i + " found defs: " + defs)
+            debuglog("ctor: " + i + " found defs: " + defs)
             assert(defs.length == 1, "wrong defs at bb " + bb + "\n" + method.dump + rdef)
             val (bb1, idx1) = defs.head
             var producer = bb1(idx1)
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
index e082e6c616..475804c2a6 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala
@@ -39,7 +39,7 @@ abstract class Pickler extends SubComponent {
       def pickle(tree: Tree) {
         def add(sym: Symbol, pickle: Pickle) = {
           if (currentRun.compiles(sym) && !currentRun.symData.contains(sym)) {
-            if (settings.debug.value) log("pickling " + sym)
+            debuglog("pickling " + sym)
             pickle putSymbol sym
             currentRun.symData(sym) = pickle
           }
diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index eb700f1610..e0c6e8678b 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -329,7 +329,7 @@ abstract class Constructors extends Transform with ast.TreeDSL {
 
             val stat2 = rewriteArrayUpdate(stat1)
             // statements coming from the original class need retyping in the current context
-            if (settings.debug.value) log("retyping " + stat2)
+            debuglog("retyping " + stat2)
 
             val d = new specializeTypes.Duplicator
             d.retyped(localTyper.context1.asInstanceOf[d.Context],
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index c2013e77f9..99df069e3b 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -649,8 +649,7 @@ abstract class Erasure extends AddInterfaces
         if (!atPhase(currentRun.refchecksPhase.next)(
               root.thisType.memberType(opc.overriding) matches
               root.thisType.memberType(opc.overridden))) {
-          if (settings.debug.value)
-            log("" + opc.overriding.locationString + " " +
+          debuglog("" + opc.overriding.locationString + " " +
                      opc.overriding.infosString +
                      opc.overridden.locationString + " " +
                      opc.overridden.infosString)
@@ -669,7 +668,7 @@ abstract class Erasure extends AddInterfaces
                 atPhase(phase.next)(member.tpe =:= other.tpe) &&
                 !atPhase(refchecksPhase.next)(
                   root.thisType.memberType(member) matches root.thisType.memberType(other))) {
-              if (settings.debug.value) log("" + member.locationString + " " + member.infosString + other.locationString + " " + other.infosString);
+              debuglog("" + member.locationString + " " + member.infosString + other.locationString + " " + other.infosString);
               doubleDefError(member, other)
             }
           }
@@ -745,8 +744,7 @@ abstract class Erasure extends AddInterfaces
                           (((Select(This(owner), member): Tree) /: bridge.paramss)
                              ((fun, vparams) => Apply(fun, vparams map Ident)))
                       });
-                  if (settings.debug.value)
-                    log("generating bridge from " + other + "(" + Flags.flagsToString(bridge.flags)  + ")" + ":" + otpe + other.locationString + " to " + member + ":" + erasure(owner, member.tpe) + member.locationString + " =\n " + bridgeDef);
+                  debuglog("generating bridge from " + other + "(" + Flags.flagsToString(bridge.flags)  + ")" + ":" + otpe + other.locationString + " to " + member + ":" + erasure(owner, member.tpe) + member.locationString + " =\n " + bridgeDef);
                   bridgeDef
                 }
               } :: bridges
@@ -797,8 +795,7 @@ abstract class Erasure extends AddInterfaces
     private val preTransformer = new TypingTransformer(unit) {
       def preErase(tree: Tree): Tree = tree match {
         case ClassDef(mods, name, tparams, impl) =>
-          if (settings.debug.value)
-            log("defs of " + tree.symbol + " = " + tree.symbol.info.decls)
+          debuglog("defs of " + tree.symbol + " = " + tree.symbol.info.decls)
           treeCopy.ClassDef(tree, mods, name, List(), impl)
         case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
           treeCopy.DefDef(tree, mods, name, List(), vparamss, tpt, rhs)
@@ -997,8 +994,7 @@ abstract class Erasure extends AddInterfaces
       val tree1 = preTransformer.transform(tree)
       atPhase(phase.next) {
         val tree2 = mixinTransformer.transform(tree1)
-        if (settings.debug.value)
-          log("tree after addinterfaces: \n" + tree2)
+        debuglog("tree after addinterfaces: \n" + tree2)
 
         newTyper(rootContext(unit, tree, true)).typed(tree2)
       }
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index 533caff078..e3cd9eb351 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -97,8 +97,7 @@ abstract class LambdaLift extends InfoTransform {
      *  }
      */
     private def markFree(sym: Symbol, enclosure: Symbol): Boolean = {
-      if (settings.debug.value)
-        log("mark free: " + sym + " of " + sym.owner + " marked free in " + enclosure)
+      debuglog("mark free: " + sym + " of " + sym.owner + " marked free in " + enclosure)
       if (enclosure == sym.owner.logicallyEnclosingMember) true
       else if (enclosure.isPackageClass || !markFree(sym, enclosure.skipConstructor.owner.logicallyEnclosingMember)) false
       else {
@@ -116,7 +115,7 @@ abstract class LambdaLift extends InfoTransform {
               sym.owner.setInfo(sym.owner.info.cloneInfo(sym.owner))
           }
           changedFreeVars = true
-          if (settings.debug.value) log("" + sym + " is free in " + enclosure);
+          debuglog("" + sym + " is free in " + enclosure);
           if ((sym.isVariable || (sym.isValue && sym.isLazy)) && !sym.hasFlag(CAPTURED)) {
             sym setFlag CAPTURED
             val symClass = sym.tpe.typeSymbol
@@ -135,8 +134,7 @@ abstract class LambdaLift extends InfoTransform {
     }
 
     private def markCalled(sym: Symbol, owner: Symbol) {
-      if (settings.debug.value)
-        log("mark called: " + sym + " of " + sym.owner + " is called by " + owner)
+      debuglog("mark called: " + sym + " of " + sym.owner + " is called by " + owner)
       symSet(called, owner) addEntry sym
     }
 
@@ -204,14 +202,12 @@ abstract class LambdaLift extends InfoTransform {
           if (sym.name.isTypeName) unit.freshTypeName(base)
           else unit.freshTermName(base)
 
-        if (settings.debug.value)
-          log("renaming in %s: %s => %s".format(sym.owner.fullLocationString, originalName, sym.name))
+        debuglog("renaming in %s: %s => %s".format(sym.owner.fullLocationString, originalName, sym.name))
       }
 
       atPhase(phase.next) {
         for ((owner, freeValues) <- free.toList) {
-          if (settings.debug.value)
-            log("free var proxy: %s, %s".format(owner.fullLocationString, freeValues.toList.mkString(", ")))
+          debuglog("free var proxy: %s, %s".format(owner.fullLocationString, freeValues.toList.mkString(", ")))
 
             proxies(owner) =
               for (fv <- freeValues.toList) yield {
@@ -228,15 +224,13 @@ abstract class LambdaLift extends InfoTransform {
 
     private def proxy(sym: Symbol) = {
       def searchIn(enclosure: Symbol): Symbol = {
-        if (settings.debug.value)
-          log("searching for " + sym + "(" + sym.owner + ") in " + enclosure + " " + enclosure.logicallyEnclosingMember)
+        debuglog("searching for " + sym + "(" + sym.owner + ") in " + enclosure + " " + enclosure.logicallyEnclosingMember)
 
         val ps = (proxies get enclosure.logicallyEnclosingMember).toList.flatten filter (_.name == sym.name)
         if (ps.isEmpty) searchIn(enclosure.skipConstructor.owner)
         else ps.head
       }
-      if (settings.debug.value)
-        log("proxy " + sym + " in " + sym.owner + " from " + currentOwner.ownerChain.mkString(" -> ") +
+      debuglog("proxy " + sym + " in " + sym.owner + " from " + currentOwner.ownerChain.mkString(" -> ") +
           " " + sym.owner.logicallyEnclosingMember)
 
       if (isSameOwnerEnclosure(sym)) sym
@@ -337,7 +331,7 @@ abstract class LambdaLift extends InfoTransform {
       if (sym.isMethod) sym setFlag LIFTED
       liftedDefs(sym.owner) ::= tree
       sym.owner.info.decls enterUnique sym
-      if (settings.debug.value) log("lifted: " + sym + " from " + oldOwner + " to " + sym.owner)
+      debuglog("lifted: " + sym + " from " + oldOwner + " to " + sym.owner)
       EmptyTree
     }
 
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index 39eb9be060..d43dfdd3d9 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -95,8 +95,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
     atPhase(currentRun.picklerPhase.next) {
       var bcs = base.info.baseClasses.dropWhile(mixinClass !=).tail
       var sym: Symbol = NoSymbol
-      if (settings.debug.value)
-        log("starting rebindsuper " + base + " " + member + ":" + member.tpe +
+      debuglog("starting rebindsuper " + base + " " + member + ":" + member.tpe +
             " " + mixinClass + " " + base.info.baseClasses + "/" + bcs)
       while (!bcs.isEmpty && sym == NoSymbol) {
         if (settings.debug.value) {
@@ -132,7 +131,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
   /** Add given member to given class, and mark member as mixed-in.
    */
   def addMember(clazz: Symbol, member: Symbol): Symbol = {
-    if (settings.debug.value) log("new member of " + clazz + ":" + member.defString)
+    debuglog("new member of " + clazz + ":" + member.defString)
     clazz.info.decls enter member
     member.setFlag(MIXEDIN)
   }
@@ -199,7 +198,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
           }
         }
       }
-      if (settings.debug.value) log("new defs of " + clazz + " = " + clazz.info.decls);
+      debuglog("new defs of " + clazz + " = " + clazz.info.decls);
     }
   }
 
@@ -609,7 +608,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
 
       /** Attribute given tree and anchor at given position */
       def attributedDef(pos: Position, tree: Tree): Tree = {
-        if (settings.debug.value) log("add new def to " + clazz + ": " + tree)
+        debuglog("add new def to " + clazz + ": " + tree)
         typedPos(pos)(tree)
       }
 
@@ -669,8 +668,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
           val rhs0 = (Super(clazz, tpnme.EMPTY) DOT stat.symbol.alias)(vparams map (v => Ident(v.symbol)): _*)
           val rhs1 = localTyper.typed(atPos(stat.pos)(rhs0), stat.symbol.tpe.resultType)
           val rhs2 = atPhase(currentRun.mixinPhase)(transform(rhs1))
-          if (settings.debug.value)
-            log("complete super acc " + stat.symbol + stat.symbol.locationString +
+          debuglog("complete super acc " + stat.symbol + stat.symbol.locationString +
                 " " + rhs1 + " " + stat.symbol.alias + stat.symbol.alias.locationString +
                 "/" + stat.symbol.alias.owner.hasFlag(lateINTERFACE))//debug
           treeCopy.DefDef(stat, mods, name, tparams, List(vparams), tpt, rhs2)
@@ -999,7 +997,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
         var fieldsCheckinitTransient = 0
 
         for (f <- clazz0.info.decls.iterator) {
-          if (settings.debug.value) log(f.fullName + " -> " + fields)
+          debuglog(f.fullName + " -> " + fields)
 
           if (fieldWithBitmap(f)) {
             val (idx, _) =
diff --git a/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala b/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala
index 1e6d86bb97..70f8d37585 100644
--- a/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala
+++ b/src/compiler/scala/tools/nsc/transform/OverridingPairs.scala
@@ -136,8 +136,7 @@ abstract class OverridingPairs {
                     include(subParents(bcIndex), pIndex)
                   case None =>
                 }
-              else if (settings.debug.value)
-                log("SKIPPING "+p+" -> "+p.baseType(bc)+" / "+self.baseType(bc)+" from "+base)
+              else debuglog("SKIPPING "+p+" -> "+p.baseType(bc)+" / "+self.baseType(bc)+" from "+base)
           case None =>
         }
       }
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index d155665de1..ade15f2c81 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -1389,8 +1389,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
 
             case SpecialOverride(target) =>
               assert(body.isDefinedAt(target), "sym: " + symbol.fullName + " target: " + target.fullName)
-              //if (settings.debug.value)
-                log("moving implementation, body of target " + target + ": " + body(target))
+              //debuglog("moving implementation, body of target " + target + ": " + body(target))
               log("%s is param accessor? %b".format(ddef.symbol, ddef.symbol.isParamAccessor))
               // we have an rhs, specialize it
               val tree1 = addBody(ddef, target)
diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
index 79bcc76988..5013e8f21d 100644
--- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala
+++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
@@ -192,8 +192,7 @@ abstract class TailCalls extends Transform {
          *  Position is unchanged (by default, the method definition.)
          */
         def fail(reason: String) = {
-          if (settings.debug.value)
-            log("Cannot rewrite recursive call at: " + fun.pos + " because: " + reason)
+          debuglog("Cannot rewrite recursive call at: " + fun.pos + " because: " + reason)
 
           ctx.failReason = reason
           treeCopy.Apply(tree, target, transformArgs)
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index bd9f24177a..8ac69f15e1 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -432,8 +432,7 @@ abstract class UnCurry extends InfoTransform
       /** Transform tree `t` to { def f = t; f } where `f` is a fresh name
        */
       def liftTree(tree: Tree) = {
-        if (settings.debug.value)
-          log("lifting tree at: " + (tree.pos))
+        debuglog("lifting tree at: " + (tree.pos))
         val sym = currentOwner.newMethod(tree.pos, unit.freshTermName("liftedTree"))
         sym.setInfo(MethodType(List(), tree.tpe))
         new ChangeOwnerTraverser(currentOwner, sym).traverse(tree)
@@ -620,7 +619,7 @@ abstract class UnCurry extends InfoTransform
                   EmptyTree,
                   Match(Ident(exname), cases))
               }
-            if (settings.debug.value) log("rewrote try: " + catches + " ==> " + catchall);
+            debuglog("rewrote try: " + catches + " ==> " + catchall);
             val catches1 = localTyper.typedCases(
               tree, List(catchall), ThrowableClass.tpe, WildcardType)
             treeCopy.Try(tree, body, catches1, finalizer)
@@ -633,7 +632,7 @@ abstract class UnCurry extends InfoTransform
         case Select(_, _) | TypeApply(_, _) =>
           applyUnary()
         case Return(expr) if (tree.symbol != currentOwner.enclMethod || currentOwner.isLazy) =>
-          if (settings.debug.value) log("non local return in "+tree.symbol+" from "+currentOwner.enclMethod)
+          debuglog("non local return in "+tree.symbol+" from "+currentOwner.enclMethod)
           atPos(tree.pos)(nonLocalReturnThrow(expr, tree.symbol))
         case TypeTree() =>
           tree
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 8e22da83b0..96b27b58ae 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -504,7 +504,7 @@ trait Contexts { self: Analyzer =>
     def restoreTypeBounds(tp: Type): Type = {
       var current = tp
       for ((sym, info) <- savedTypeBounds) {
-        if (settings.debug.value) log("resetting " + sym + " to " + info);
+        debuglog("resetting " + sym + " to " + info);
         sym.info match {
           case TypeBounds(lo, hi) if (hi <:< lo && lo <:< hi) =>
             current = current.instantiateTypeParams(List(sym), List(lo))
@@ -558,7 +558,7 @@ trait Contexts { self: Analyzer =>
           }
           impls
       }
-      //if (settings.debug.value) log("collect implicit imports " + imp + "=" + collect(imp.tree.selectors))//DEBUG
+      //debuglog("collect implicit imports " + imp + "=" + collect(imp.tree.selectors))//DEBUG
       collect(imp.tree.selectors)
     }
 
@@ -570,14 +570,14 @@ trait Contexts { self: Analyzer =>
         val newImplicits: List[ImplicitInfo] =
           if (owner != nextOuter.owner && owner.isClass && !owner.isPackageClass && !inSelfSuperCall) {
             if (!owner.isInitialized) return nextOuter.implicitss
-            // if (settings.debug.value) log("collect member implicits " + owner + ", implicit members = " + owner.thisType.implicitMembers)//DEBUG
+            // debuglog("collect member implicits " + owner + ", implicit members = " + owner.thisType.implicitMembers)//DEBUG
             val savedEnclClass = enclClass
             this.enclClass = this
             val res = collectImplicits(owner.thisType.implicitMembers, owner.thisType)
             this.enclClass = savedEnclClass
             res
           } else if (scope != nextOuter.scope && !owner.isPackageClass) {
-            if (settings.debug.value) log("collect local implicits " + scope.toList)//DEBUG
+            debuglog("collect local implicits " + scope.toList)//DEBUG
             collectImplicits(scope.toList, NoPrefix)
           } else if (imports != nextOuter.imports) {
             assert(imports.tail == nextOuter.imports)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
index 44c566030b..16b01d3f05 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
@@ -196,11 +196,11 @@ abstract class Duplicators extends Analyzer {
      *  namer/typer handle them, or Idents that refer to them.
      */
     override def typed(tree: Tree, mode: Int, pt: Type): Tree = {
-      if (settings.debug.value) log("typing " + tree + ": " + tree.tpe)
+      debuglog("typing " + tree + ": " + tree.tpe)
       if (tree.hasSymbol && tree.symbol != NoSymbol
           && !tree.symbol.isLabel  // labels cannot be retyped by the type checker as LabelDef has no ValDef/return type trees
           && invalidSyms.isDefinedAt(tree.symbol)) {
-        if (settings.debug.value) log("removed symbol " + tree.symbol)
+        debuglog("removed symbol " + tree.symbol)
         tree.symbol = NoSymbol
       }
 
@@ -266,7 +266,7 @@ abstract class Duplicators extends Analyzer {
           // log("selection on this: " + tree)
           val tree1 = This(newClassOwner)
           // log("tree1: " + tree1)
-          if (settings.debug.value) log("mapped " + tree + " to " + tree1)
+          debuglog("mapped " + tree + " to " + tree1)
           super.typed(atPos(tree.pos)(tree1), mode, pt)
 
         case This(_) =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index d4986e3dc1..2a6fc122e2 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -1323,15 +1323,15 @@ trait Infer {
       if (restpe.instantiateTypeParams(undetparams, tvars) <:< pt) {
         computeArgs
       } else if (isFullyDefined(pt)) {
-        if (settings.debug.value) log("infer constr " + tree + ":" + restpe + ", pt = " + pt)
+        debuglog("infer constr " + tree + ":" + restpe + ", pt = " + pt)
         var ptparams = freeTypeParamsOfTerms.collect(pt)
-        if (settings.debug.value) log("free type params = " + ptparams)
+        debuglog("free type params = " + ptparams)
         val ptWithWildcards = pt.instantiateTypeParams(ptparams, ptparams map (ptparam => WildcardType))
         tvars = undetparams map freshVar
         if (restpe.instantiateTypeParams(undetparams, tvars) <:< ptWithWildcards) {
           computeArgs
           restpe = skipImplicit(tree.tpe.resultType)
-          if (settings.debug.value) log("new tree = " + tree + ":" + restpe)
+          debuglog("new tree = " + tree + ":" + restpe)
           val ptvars = ptparams map freshVar
           val pt1 = pt.instantiateTypeParams(ptparams, ptvars)
           if (isPopulated(restpe, pt1)) {
@@ -1370,7 +1370,7 @@ trait Infer {
         context.nextEnclosing(_.tree.isInstanceOf[CaseDef]).pushTypeBounds(tparam)
         tparam setInfo tvar.constr.inst
         tparam resetFlag DEFERRED
-        if (settings.debug.value) log("new alias of " + tparam + " = " + tparam.info)
+        debuglog("new alias of " + tparam + " = " + tparam.info)
       } else {
         val (lo, hi) = instBounds(tvar)
         if (lo <:< hi) {
@@ -1378,12 +1378,12 @@ trait Infer {
              && tparam != lo.typeSymbolDirect && tparam != hi.typeSymbolDirect) { // don't create illegal cycles
             context.nextEnclosing(_.tree.isInstanceOf[CaseDef]).pushTypeBounds(tparam)
             tparam setInfo TypeBounds(lo, hi)
-            if (settings.debug.value) log("new bounds of " + tparam + " = " + tparam.info)
+            debuglog("new bounds of " + tparam + " = " + tparam.info)
           } else {
-            if (settings.debug.value) log("redundant: "+tparam+" "+tparam.info+"/"+lo+" "+hi)
+            debuglog("redundant: "+tparam+" "+tparam.info+"/"+lo+" "+hi)
           }
         } else {
-          if (settings.debug.value) log("inconsistent: "+tparam+" "+lo+" "+hi)
+          debuglog("inconsistent: "+tparam+" "+lo+" "+hi)
         }
       }
     }
@@ -1474,8 +1474,7 @@ trait Infer {
       checkCheckable(pos, pattp, "pattern ")
       if (pattp <:< pt) ()
       else {
-        if (settings.debug.value)
-          log("free type params (1) = " + tpparams)
+        debuglog("free type params (1) = " + tpparams)
 
         var tvars = tpparams map freshVar
         var tp    = pattp.instantiateTypeParams(tpparams, tvars)
@@ -1485,8 +1484,7 @@ trait Infer {
           tvars = tpparams map freshVar
           tp    = pattp.instantiateTypeParams(tpparams, tvars)
 
-          if (settings.debug.value)
-            log("free type params (2) = " + ptparams)
+          debuglog("free type params (2) = " + ptparams)
 
           val ptvars = ptparams map freshVar
           val pt1    = pt.instantiateTypeParams(ptparams, ptvars)
@@ -1513,7 +1511,7 @@ trait Infer {
     def inferModulePattern(pat: Tree, pt: Type) =
       if (!(pat.tpe <:< pt)) {
         val ptparams = freeTypeParamsOfTerms.collect(pt)
-        if (settings.debug.value) log("free type params (2) = " + ptparams)
+        debuglog("free type params (2) = " + ptparams)
         val ptvars = ptparams map freshVar
         val pt1 = pt.instantiateTypeParams(ptparams, ptvars)
         if (pat.tpe <:< pt1)
@@ -1655,8 +1653,7 @@ trait Infer {
       case OverloadedType(pre, alts) =>
         val pt = if (pt0.typeSymbol == UnitClass) WildcardType else pt0
         tryTwice {
-          if (settings.debug.value)
-            log("infer method alt "+ tree.symbol +" with alternatives "+
+          debuglog("infer method alt "+ tree.symbol +" with alternatives "+
                 (alts map pre.memberType) +", argtpes = "+ argtpes +", pt = "+ pt)
 
           var allApplicable = alts filter (alt =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 6bbb94bf29..9562862f0a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -83,7 +83,7 @@ trait Namers { self: Analyzer =>
       (moduleFlags & ModuleToClassFlags) | FINAL | inConstructorFlag
 
     def updatePosFlags(sym: Symbol, pos: Position, flags: Long): Symbol = {
-      if (settings.debug.value) log("overwriting " + sym)
+      debuglog("overwriting " + sym)
       val lockedFlag = sym.flags & LOCKED
       sym.reset(NoType)
       sym setPos pos
@@ -305,7 +305,7 @@ trait Namers { self: Analyzer =>
 
     private def enterSymFinishWith(tree: Tree, tparams: List[TypeDef]) {
       val sym = tree.symbol
-      if (settings.debug.value) log("entered " + sym + " in " + context.owner + ", scope-id = " + context.scope.## )
+      debuglog("entered " + sym + " in " + context.owner + ", scope-id = " + context.scope.## )
       var ltype = namerOf(sym).typeCompleter(tree)
       if (tparams nonEmpty) {
         //@M! TypeDef's type params are handled differently
@@ -547,7 +547,7 @@ trait Namers { self: Analyzer =>
 // --- Lazy Type Assignment --------------------------------------------------
 
     def typeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym =>
-      if (settings.debug.value) log("defining " + sym + flagsToString(sym.flags)+sym.locationString)
+      debuglog("defining " + sym + flagsToString(sym.flags)+sym.locationString)
       val tp = typeSig(tree)
       tp match {
         case TypeBounds(lo, hi) =>
@@ -565,7 +565,7 @@ trait Namers { self: Analyzer =>
           !typer.checkNonCyclic(tree.pos, tp))
         sym.setInfo(ErrorType) // this early test is there to avoid infinite baseTypes when
                                // adding setters and getters --> bug798
-      if (settings.debug.value) log("defined " + sym);
+      debuglog("defined " + sym);
       validate(sym)
     }
 
@@ -579,18 +579,18 @@ trait Namers { self: Analyzer =>
     }
 
     def getterTypeCompleter(vd: ValDef) = mkTypeCompleter(vd) { sym =>
-      if (settings.debug.value) log("defining " + sym)
+      debuglog("defining " + sym)
       val tp = typeSig(vd)
       sym.setInfo(NullaryMethodType(tp))
-      if (settings.debug.value) log("defined " + sym)
+      debuglog("defined " + sym)
       validate(sym)
     }
 
     def setterTypeCompleter(vd: ValDef) = mkTypeCompleter(vd) { sym =>
-      if (settings.debug.value) log("defining " + sym)
+      debuglog("defining " + sym)
       val param = sym.newSyntheticValueParam(typeSig(vd))
       sym.setInfo(MethodType(List(param), UnitClass.tpe))
-      if (settings.debug.value) log("defined " + sym)
+      debuglog("defined " + sym)
       validate(sym)
     }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index f178274e3e..914e9c7dbc 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -95,7 +95,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
           val supername = nme.superName(sym.name)
           var superAcc = clazz.info.decl(supername).suchThat(_.alias == sym)
           if (superAcc == NoSymbol) {
-            if (settings.debug.value) log("add super acc " + sym + sym.locationString + " to `" + clazz);//debug
+            debuglog("add super acc " + sym + sym.locationString + " to `" + clazz);//debug
             superAcc =
               clazz.newMethod(tree.pos, supername)
                 .setFlag(SUPERACCESSOR | PRIVATE)
@@ -133,8 +133,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
 
       def mayNeedProtectedAccessor(sel: Select, args: List[Tree], goToSuper: Boolean) =
         if (needsProtectedAccessor(sym, tree.pos)) {
-          if (settings.debug.value)
-            log("Adding protected accessor for " + tree)
+          debuglog("Adding protected accessor for " + tree)
 
           transform(makeAccessor(sel, args))
         }
@@ -198,8 +197,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
                   Super(qual, tpnme.EMPTY/*qual.symbol.info.parents.head.symbol.name*/) setPos qual.pos,
                   sym.alias) setPos tree.pos
             }
-            if (settings.debug.value)
-              log("alias replacement: " + tree + " ==> " + result);//debug
+            debuglog("alias replacement: " + tree + " ==> " + result);//debug
             localTyper.typed(gen.maybeMkAsInstanceOf(transformSuperSelect(result), sym.tpe, sym.alias.tpe, true))
           }
           else mayNeedProtectedAccessor(sel, List(EmptyTree), false)
@@ -224,10 +222,9 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
           if (lhs.symbol.isVariable &&
               lhs.symbol.isJavaDefined &&
               needsProtectedAccessor(lhs.symbol, tree.pos)) {
-            if (settings.debug.value) log("Adding protected setter for " + tree)
+            debuglog("Adding protected setter for " + tree)
             val setter = makeSetter(lhs);
-            if (settings.debug.value)
-              log("Replaced " + tree + " with " + setter);
+            debuglog("Replaced " + tree + " with " + setter);
             transform(localTyper.typed(Apply(setter, List(qual, rhs))))
           } else
             super.transform(tree)
@@ -283,7 +280,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
 
 
       assert(clazz != NoSymbol, sym)
-      if (settings.debug.value)  log("Decided for host class: " + clazz)
+      debuglog("Decided for host class: " + clazz)
 
       val accName = nme.protName(sym.originalName)
       val hasArgs = sym.tpe.paramTypes != Nil
@@ -315,8 +312,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
               })
         })
 
-        if (settings.debug.value)
-          log(code)
+        debuglog("" + code)
         accDefBuf(clazz) += typers(clazz).typed(code)
       }
       var res: Tree = atPos(tree.pos) {
@@ -325,8 +321,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
         else
           Apply(TypeApply(Select(This(clazz), protAcc), targs), List(qual))
       }
-      if (settings.debug.value)
-        log("Replaced " + tree + " with " + res)
+      debuglog("Replaced " + tree + " with " + res)
       if (hasArgs) localTyper.typedOperator(res) else localTyper.typed(res)
     }
 
@@ -377,8 +372,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
       val field = tree.symbol
       val clazz = hostForAccessorOf(field, currentOwner.enclClass)
       assert(clazz != NoSymbol, field)
-      if (settings.debug.value)
-        log("Decided for host class: " + clazz)
+      debuglog("Decided for host class: " + clazz)
       val accName = nme.protSetterName(field.originalName)
       var protAcc = clazz.info.decl(accName)
       if (protAcc == NoSymbol) {
@@ -394,8 +388,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
               Ident(value))
           }
         })
-        if (settings.debug.value)
-          log(code);
+        debuglog("" + code)
         accDefBuf(clazz) += typers(clazz).typed(code)
       }
       var res: Tree = atPos(tree.pos) { Select(This(clazz), protAcc) }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 1988bc887f..185529ed74 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -156,7 +156,7 @@ trait Typers extends Modes {
      *                          whether one type is coercible to another.
      */
     def inferView(tree: Tree, from: Type, to: Type, reportAmbiguous: Boolean): Tree = {
-      if (settings.debug.value) log("infer view from "+from+" to "+to)//debug
+      debuglog("infer view from "+from+" to "+to)//debug
       if (phase.id > currentRun.typerPhase.id) EmptyTree
       else from match {
         case MethodType(_, _) => EmptyTree
@@ -760,7 +760,7 @@ trait Typers extends Modes {
           typer1.silent(tpr => tpr.typed(tpr.applyImplicitArgs(tree), mode, pt)) match {
             case result: Tree => result
             case ex: TypeError =>
-              if (settings.debug.value) log("fallback on implicits: "+tree+"/"+resetAllAttrs(original))
+              debuglog("fallback on implicits: "+tree+"/"+resetAllAttrs(original))
               val tree1 = typed(resetAllAttrs(original), mode, WildcardType)
               tree1.tpe = addAnnotations(tree1, tree1.tpe)
               if (tree1.isEmpty) tree1 else adapt(tree1, mode, pt, EmptyTree)
@@ -777,7 +777,7 @@ trait Typers extends Modes {
           case _ => tree.symbol
         }
         if (!meth.isConstructor && isFunctionType(pt)) { // (4.2)
-          if (settings.debug.value) log("eta-expanding "+tree+":"+tree.tpe+" to "+pt)
+          debuglog("eta-expanding "+tree+":"+tree.tpe+" to "+pt)
           checkParamsConvertible(tree.pos, tree.tpe)
           val tree0 = etaExpand(context.unit, tree)
           // println("eta "+tree+" ---> "+tree0+":"+tree0.tpe+" undet: "+context.undetparams+ " mode: "+Integer.toHexString(mode))
@@ -919,18 +919,17 @@ trait Typers extends Modes {
               }
               if (context.implicitsEnabled && !tree.tpe.isError && !pt.isError) {
                 // (14); the condition prevents chains of views
-                if (settings.debug.value) log("inferring view from "+tree.tpe+" to "+pt)
+                debuglog("inferring view from "+tree.tpe+" to "+pt)
                 val coercion = inferView(tree, tree.tpe, pt, true)
                 // convert forward views of delegate types into closures wrapped around
                 // the delegate's apply method (the "Invoke" method, which was translated into apply)
                 if (forMSIL && coercion != null && isCorrespondingDelegate(tree.tpe, pt)) {
                   val meth: Symbol = tree.tpe.member(nme.apply)
-                  if(settings.debug.value)
-                    log("replacing forward delegate view with: " + meth + ":" + meth.tpe)
+                  debuglog("replacing forward delegate view with: " + meth + ":" + meth.tpe)
                   return typed(Select(tree, meth), mode, pt)
                 }
                 if (coercion != EmptyTree) {
-                  if (settings.debug.value) log("inferred view from "+tree.tpe+" to "+pt+" = "+coercion+":"+coercion.tpe)
+                  debuglog("inferred view from "+tree.tpe+" to "+pt+" = "+coercion+":"+coercion.tpe)
                   return newTyper(context.makeImplicit(context.reportAmbiguousErrors)).typed(
                     new ApplyImplicitView(coercion, List(tree)) setPos tree.pos, mode, pt)
                 }
@@ -1024,7 +1023,7 @@ trait Typers extends Modes {
           case result: Tree if result != qual =>
             result
           case _ =>
-            if (settings.debug.value) log("fallback on implicits in adaptToArguments: "+qual+" . "+name)
+            debuglog("fallback on implicits in adaptToArguments: "+qual+" . "+name)
             doAdapt(WildcardType)
         }
       } else
@@ -1583,7 +1582,7 @@ trait Typers extends Modes {
      *  @param rhs      ...
      */
     def computeParamAliases(clazz: Symbol, vparamss: List[List[ValDef]], rhs: Tree) {
-      if (settings.debug.value) log("computing param aliases for "+clazz+":"+clazz.primaryConstructor.tpe+":"+rhs)//debug
+      debuglog("computing param aliases for "+clazz+":"+clazz.primaryConstructor.tpe+":"+rhs)//debug
       def decompose(call: Tree): (Tree, List[Tree]) = call match {
         case Apply(fn, args) =>
           val (superConstr, args1) = decompose(fn)
@@ -1635,8 +1634,7 @@ trait Typers extends Modes {
                       if ((ownAcc hasFlag ACCESSOR) && !ownAcc.isDeferred)
                         ownAcc = ownAcc.accessed
                       if (!ownAcc.isVariable && !alias.accessed.isVariable) {
-                        if (settings.debug.value)
-                          log("" + ownAcc + " has alias "+alias + alias.locationString) //debug
+                        debuglog("" + ownAcc + " has alias "+alias + alias.locationString) //debug
                         ownAcc.asInstanceOf[TermSymbol].setAlias(alias)
                       }
                     }
@@ -2497,7 +2495,7 @@ trait Typers extends Modes {
               val args1 = (args, formals).zipped map typedArgToPoly
               if (args1 exists (_.tpe.isError)) setError(tree)
               else {
-                if (settings.debug.value) log("infer method inst "+fun+", tparams = "+tparams+", args = "+args1.map(_.tpe)+", pt = "+pt+", lobounds = "+tparams.map(_.tpe.bounds.lo)+", parambounds = "+tparams.map(_.info)) //debug
+                debuglog("infer method inst "+fun+", tparams = "+tparams+", args = "+args1.map(_.tpe)+", pt = "+pt+", lobounds = "+tparams.map(_.tpe.bounds.lo)+", parambounds = "+tparams.map(_.info)) //debug
                 // define the undetparams which have been fixed by this param list, replace the corresponding symbols in "fun"
                 // returns those undetparams which have not been instantiated.
                 val undetparams = inferMethodInstance(fun, tparams, args1, pt)
@@ -3469,7 +3467,7 @@ trait Typers extends Modes {
         }
         typed1(tree1, mode, pt)
 /*
-        if (settings.debug.value) log("retry assign: "+tree1)
+        debuglog("retry assign: "+tree1)
         silent(_.typed1(tree1, mode, pt)) match {
           case t: Tree =>
             t
@@ -4245,8 +4243,7 @@ trait Typers extends Modes {
 
       def dropExistential(tp: Type): Type = tp match {
         case ExistentialType(tparams, tpe) =>
-          if (settings.debug.value)
-            log("Dropping existential: " + tree + " " + tp)
+          debuglog("Dropping existential: " + tree + " " + tp)
           new SubstWildcardMap(tparams).apply(tp)
         case TypeRef(_, sym, _) if sym.isAliasType =>
           val tp0 = tp.normalize
diff --git a/src/compiler/scala/tools/nsc/util/FlagsUtil.scala b/src/compiler/scala/tools/nsc/util/FlagsUtil.scala
index 7574859e03..b615775468 100644
--- a/src/compiler/scala/tools/nsc/util/FlagsUtil.scala
+++ b/src/compiler/scala/tools/nsc/util/FlagsUtil.scala
@@ -47,9 +47,6 @@ class TransFlagManager[T <: Global](val global: T) {
     private val mask               = symtab.Flags.TRANS_FLAG
     private val seen               = new mutable.HashSet[Symbol]
 
-    private def debug(msg: String) = if (settings.debug.value) log(msg)
-    private def trace(msg: String) = if (settings.debug.value && settings.verbose.value) log(msg)
-    private def isDebug            = settings.debug.value
     private def doWeOwnFlag        = trackerStack.headOption exists (_ eq this)
     private def isOK               = trackerStack.isEmpty || (trackerStack.head eq this)