Add '-deprecation' option to ScoverageCompiler and fix reported deprecation warnings

All warning are macro-related and reported when Scala version is >= 2.11. There were three kinds:

1.
scoverage_snippet6266375223143133247.scala:5: warning: macro defs must have explicitly specified return types (inference of Unit from macro impl's c.Expr[Unit] is deprecated and is going to stop working in 2.12)
  def test = macro testImpl
      ^

2.
scoverage_snippet6266375223143133247.scala:6: warning: type Context in package macros is deprecated: Use blackbox.Context or whitebox.Context instead
  def testImpl(c: Context): c.Expr[Unit] = {
                  ^

3.
scoverage_snippet6689360552943102771.scala:6: warning: method literal in trait ExprUtils is deprecated: Use quasiquotes instead
                def poly[T: c.WeakTypeTag] = c.literal(c.weakTypeOf[T].toString)
                                               ^

Author: gslowikowski

scalac-scoverage-plugin/src/test/scala/scoverage/MacroSupport.scala

@@ -4,6 +4,13 @@ import java.io.File
 
 trait MacroSupport {
 
+  val macroContextPackageName: String = if (ScoverageCompiler.ShortScalaVersion == "2.10") {
+    "scala.reflect.macros"
+  }
+  else {
+    "scala.reflect.macros.blackbox"
+  }
+
   val macroSupportDeps = Seq(testClasses)
 
   private def testClasses: File = new File(s"./scalac-scoverage-plugin/target/scala-${ScoverageCompiler.ShortScalaVersion}/test-classes")

scalac-scoverage-plugin/src/test/scala/scoverage/PluginASTSupportTest.scala

@@ -83,11 +83,11 @@ class PluginASTSupportTest
 
   test("scoverage component should ignore basic macros") {
     val compiler = ScoverageCompiler.default
-    compiler.compileCodeSnippet( """
+    compiler.compileCodeSnippet( s"""
                           | object MyMacro {
                           | import scala.language.experimental.macros
-                          | import scala.reflect.macros.Context
-                          |  def test = macro testImpl
+                          | import ${macroContextPackageName}.Context
+                          |  def test: Unit = macro testImpl
                           |  def testImpl(c: Context): c.Expr[Unit] = {
                           |    import c.universe._
                           |    reify {
@@ -100,12 +100,12 @@ class PluginASTSupportTest
 
   test("scoverage component should ignore complex macros #11") {
     val compiler = ScoverageCompiler.default
-    compiler.compileCodeSnippet( """ object ComplexMacro {
+    compiler.compileCodeSnippet( s""" object ComplexMacro {
                           |
                           |  import scala.language.experimental.macros
-                          |  import scala.reflect.macros.Context
+                          |  import ${macroContextPackageName}.Context
                           |
-                          |  def debug(params: Any*) = macro debugImpl
+                          |  def debug(params: Any*): Unit = macro debugImpl
                           |
                           |  def debugImpl(c: Context)(params: c.Expr[Any]*) = {
                           |    import c.universe._
@@ -114,7 +114,7 @@ class PluginASTSupportTest
                           |      case Literal(Constant(_)) => reify { print(param.splice) }
                           |      case _ => reify {
                           |        val variable = c.Expr[String](Literal(Constant(show(param.tree)))).splice
-                          |        print(s"$variable = ${param.splice}")
+                          |        print(s"$$variable = $${param.splice}")
                           |      }
                           |    }).tree
                           |    }

scalac-scoverage-plugin/src/test/scala/scoverage/PluginCoverageTest.scala

@@ -35,18 +35,18 @@ class PluginCoverageTest
               }
 
               object Macros {
-                def poly[T] = macro Impl.poly[T]
+                def poly[T]: String = macro Impl.poly[T]
               }"""
     else
-               """
+               s"""
               import scala.language.experimental.macros
-              import scala.reflect.macros.Context
+              import scala.reflect.macros.blackbox.Context
               class Impl(val c: Context) {
                 import c.universe._
-                def poly[T: c.WeakTypeTag] = c.literal(c.weakTypeOf[T].toString)
+                def poly[T: c.WeakTypeTag] = q"$${c.weakTypeOf[T].toString}"
               }
               object Macros {
-                def poly[T] = macro Impl.poly[T]
+                def poly[T]: String = macro Impl.poly[T]
               }"""
     compiler.compileCodeSnippet(code)
     assert(!compiler.reporter.hasErrors)
@@ -269,11 +269,11 @@ class PluginCoverageTest
 
   test("plugin should not instrument local macro implementation") {
     val compiler = ScoverageCompiler.default
-    compiler.compileCodeSnippet( """
+    compiler.compileCodeSnippet( s"""
                                    | object MyMacro {
                                    | import scala.language.experimental.macros
-                                   | import scala.reflect.macros.Context
-                                   |  def test = macro testImpl
+                                   | import ${macroContextPackageName}.Context
+                                   |  def test: Unit = macro testImpl
                                    |  def testImpl(c: Context): c.Expr[Unit] = {
                                    |    import c.universe._
                                    |    reify {

scalac-scoverage-plugin/src/test/scala/scoverage/ScoverageCompiler.scala

@@ -22,6 +22,7 @@ object ScoverageCompiler {
   def settings: Settings = {
     val s = new scala.tools.nsc.Settings
     s.Xprint.value = List("all")
+    s.deprecation.value = true
     s.Yrangepos.value = true
     s.Yposdebug.value = true
     s.classpath.value = classPath.mkString(File.pathSeparator)