Merge pull request #2505 from scalamacros/topic/macros

some fixes for macros: one esoteric, and one quite critical

3 files changed, 25 insertions, 31 deletions

diff --git a/src/compiler/scala/reflect/macros/util/Traces.scala b/src/compiler/scala/reflect/macros/util/Traces.scala
index d16916b753..2dffc68745 100644
--- a/src/compiler/scala/reflect/macros/util/Traces.scala
+++ b/src/compiler/scala/reflect/macros/util/Traces.scala
@@ -6,8 +6,6 @@ trait Traces {
 
   val macroDebugLite = globalSettings.YmacrodebugLite.value
   val macroDebugVerbose = globalSettings.YmacrodebugVerbose.value
-  val macroTraceLite = scala.tools.nsc.util.trace when (macroDebugLite || macroDebugVerbose)
-  val macroTraceVerbose = scala.tools.nsc.util.trace when macroDebugVerbose
   @inline final def macroLogLite(msg: => Any) { if (macroDebugLite || macroDebugVerbose) println(msg) }
   @inline final def macroLogVerbose(msg: => Any) { if (macroDebugVerbose) println(msg) }
 }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 0ba30ffa73..5955081345 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -341,11 +341,14 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
     }
 
     import SigGenerator._
-    macroTraceVerbose("generating macroImplSigs for: ")(macroDef)
-    macroTraceVerbose("tparams are: ")(tparams)
-    macroTraceVerbose("vparamss are: ")(vparamss)
-    macroTraceVerbose("retTpe is: ")(retTpe)
-    macroTraceVerbose("macroImplSig is: ")((paramss, implRetTpe))
+    macroLogVerbose(sm"""
+      |generating macroImplSigs for: $macroDef
+      |tparams are: $tparams
+      |vparamss are: $vparamss
+      |retTpe is: $retTpe
+      |macroImplSig is: $paramss, $implRetTpe
+    """.trim)
+    (paramss, implRetTpe)
   }
 
   /** Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method,
@@ -505,7 +508,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
   type MacroRuntime = MacroArgs => Any
   private val macroRuntimesCache = perRunCaches.newWeakMap[Symbol, MacroRuntime]
   private def macroRuntime(macroDef: Symbol): MacroRuntime = {
-    macroTraceVerbose("looking for macro implementation: ")(macroDef)
+    macroLogVerbose(s"looking for macro implementation: $macroDef")
     if (fastTrack contains macroDef) {
       macroLogVerbose("macro expansion is serviced by a fast track")
       fastTrack(macroDef)
@@ -522,18 +525,18 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
         // upd. my latest experiments show that everything's okay
         // it seems that in 2.10.1 we can easily switch to Scala reflection
         try {
-          macroTraceVerbose("loading implementation class: ")(className)
-          macroTraceVerbose("classloader is: ")(ReflectionUtils.show(macroClassloader))
+          macroLogVerbose(s"loading implementation class: $className")
+          macroLogVerbose(s"classloader is: ${ReflectionUtils.show(macroClassloader)}")
           val implObj = ReflectionUtils.staticSingletonInstance(macroClassloader, className)
           // relies on the fact that macro impls cannot be overloaded
           // so every methName can resolve to at maximum one method
           val implMeths = implObj.getClass.getDeclaredMethods.find(_.getName == methName)
           val implMeth = implMeths getOrElse { throw new NoSuchMethodException(s"$className.$methName") }
-          macroLogVerbose("successfully loaded macro impl as (%s, %s)".format(implObj, implMeth))
+          macroLogVerbose(s"successfully loaded macro impl as ($implObj, $implMeth)")
           args => implMeth.invoke(implObj, ((args.c +: args.others) map (_.asInstanceOf[AnyRef])): _*)
         } catch {
           case ex: Exception =>
-            macroTraceVerbose(s"macro runtime failed to load: ")(ex.toString)
+            macroLogVerbose(s"macro runtime failed to load: ${ex.toString}")
             macroDef setFlag IS_ERROR
             null
         }
@@ -577,8 +580,8 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
     if (argcDoesntMatch && !nullaryArgsEmptyParams) { typer.TyperErrorGen.MacroPartialApplicationError(expandee) }
 
     val argss: List[List[Any]] = exprArgs.toList
-    macroTraceVerbose("context: ")(context)
-    macroTraceVerbose("argss: ")(argss)
+    macroLogVerbose(s"context: $context")
+    macroLogVerbose(s"argss: $argss")
 
     val preparedArgss: List[List[Any]] =
       if (fastTrack contains macroDef) {
@@ -602,7 +605,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
         // whereas V won't be resolved by asSeenFrom and need to be loaded directly from `expandee` which needs to contain a TypeApply node
         // also, macro implementation reference may contain a regular type as a type argument, then we pass it verbatim
         val binding = loadMacroImplBinding(macroDef)
-        macroTraceVerbose("binding: ")(binding)
+        macroLogVerbose(s"binding: $binding")
         val tags = binding.signature filter (_ != -1) map (paramPos => {
           val targ = binding.targs(paramPos).tpe.typeSymbol
           val tpe = if (targ.isTypeParameterOrSkolem) {
@@ -620,7 +623,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
             targ.tpe
           context.WeakTypeTag(tpe)
         })
-        macroTraceVerbose("tags: ")(tags)
+        macroLogVerbose(s"tags: $tags")
 
         // transforms argss taking into account varargness of paramss
         // note that typetag context bounds are only declared on macroImpls
@@ -637,7 +640,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
           } else as
         })
       }
-    macroTraceVerbose("preparedArgss: ")(preparedArgss)
+    macroLogVerbose(s"preparedArgss: $preparedArgss")
     MacroArgs(context, preparedArgss.flatten)
   }
 
@@ -695,7 +698,8 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
               val numErrors    = reporter.ERROR.count
               def hasNewErrors = reporter.ERROR.count > numErrors
               val result = typer.context.withImplicitsEnabled(typer.typed(tree, EXPRmode, pt))
-              macroTraceVerbose(s"""${if (hasNewErrors) "failed to typecheck" else "successfully typechecked"} against $phase $pt:\n$result\n""")(result)
+              macroLogVerbose(s"""${if (hasNewErrors) "failed to typecheck" else "successfully typechecked"} against $phase $pt:\n$result""")
+              result
             }
 
             var expectedTpe = expandee.tpe
@@ -724,7 +728,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
     withInfoLevel(nodePrinters.InfoLevel.Quiet) {
       if (expandee.symbol.isErroneous || (expandee exists (_.isErroneous))) {
         val reason = if (expandee.symbol.isErroneous) "not found or incompatible macro implementation" else "erroneous arguments"
-        macroTraceVerbose("cancelled macro expansion because of %s: ".format(reason))(expandee)
+        macroLogVerbose(s"cancelled macro expansion because of $reason: $expandee")
         return Cancel(typer.infer.setError(expandee))
       }
 
@@ -794,7 +798,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
   private def macroExpandWithoutRuntime(typer: Typer, expandee: Tree): MacroExpansionResult = {
     import typer.TyperErrorGen._
     val fallbackSym = expandee.symbol.nextOverriddenSymbol orElse MacroImplementationNotFoundError(expandee)
-    macroTraceLite("falling back to: ")(fallbackSym)
+    macroLogLite(s"falling back to: $fallbackSym")
 
     def mkFallbackTree(tree: Tree): Tree = {
       tree match {
@@ -846,7 +850,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
           undetparams --= undetNoMore map (_.id)
           if (undetparams.isEmpty) {
             hasPendingMacroExpansions = true
-            macroTraceVerbose("macro expansion is pending: ")(expandee)
+            macroLogVerbose(s"macro expansion is pending: $expandee")
           }
         case _ =>
           // do nothing
diff --git a/src/reflect/scala/reflect/runtime/ReflectionUtils.scala b/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
index 7b093e0e80..33ad6d2430 100644
--- a/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
+++ b/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
@@ -28,15 +28,6 @@ private[scala] object ReflectionUtils {
     case ex if pf isDefinedAt unwrapThrowable(ex)   => pf(unwrapThrowable(ex))
   }
 
-  private def systemProperties: Iterator[(String, String)] = {
-    import scala.collection.JavaConverters._
-    System.getProperties.asScala.iterator
-  }
-
-  private def inferBootClasspath: String = (
-    systemProperties find (_._1 endsWith ".boot.class.path") map (_._2) getOrElse ""
-  )
-
   def show(cl: ClassLoader): String = {
     import scala.language.reflectiveCalls
 
@@ -51,7 +42,8 @@ private[scala] object ReflectionUtils {
       case cl if cl != null && isAbstractFileClassLoader(cl.getClass) =>
         cl.asInstanceOf[{val root: scala.reflect.io.AbstractFile}].root.canonicalPath
       case null =>
-        inferBootClasspath
+        val loadBootCp = (flavor: String) => scala.util.Properties.propOrNone(flavor + ".boot.class.path")
+        loadBootCp("sun") orElse loadBootCp("java") getOrElse "<unknown>"
       case _ =>
         "<unknown>"
     }