#32 fixed match warnings by instrumenting selector as a tree

Author: sksamuel

src/main/scala/scoverage/plugin.scala

@@ -169,7 +169,7 @@ class ScoverageInstrumentationComponent(val global: Global)
       })
     }
 
-    def instrument(tree: Tree, branch: Boolean = false) = {
+    def instrument(tree: Tree, branch: Boolean = false): Tree = {
       safeSource(tree) match {
         case None =>
           println(s"[warn] Could not instrument [${tree.getClass.getSimpleName}/${tree.symbol}]. No position.")
@@ -436,14 +436,21 @@ class ScoverageInstrumentationComponent(val global: Global)
         case l: Literal => instrument(l)
 
         // pattern match clauses will be instrumented per case
-        case m@Match(clause: Tree, cases: List[CaseDef]) =>
+        case m@Match(selector: Tree, cases: List[CaseDef]) =>
           // we can be fairly sure this was generated as part of a for loop
-          if (m.selector.toString().contains("check$")
-            && m.selector.tpe.annotations.mkString == "unchecked"
-            && m.cases.last.toString == "case _ => false") // todo check these assumptions for 2.11
-            treeCopy.Match(tree, instrument(clause), transformCases(cases.dropRight(1)) ++ cases.takeRight(1))
-          else
-            treeCopy.Match(tree, instrument(clause), transformCases(cases))
+          if (selector.toString().contains("check$")
+            && selector.tpe.annotations.mkString == "unchecked"
+            && m.cases.last.toString == "case _ => false") {
+            // todo check these assumptions for 2.11
+            treeCopy.Match(tree, instrument(selector), transformCases(cases.dropRight(1)) ++ cases.takeRight(1))
+          } else {
+            //            import scala.reflect.runtime.universe.{reify, showRaw}
+            //            val _selector = reify {
+            //              Match(Annotated(Apply(Select(New(Ident(scala.unchecked)), nme.CONSTRUCTOR), List()),
+            //                Ident(newTermName("name")))
+            //          }
+            instrument(treeCopy.Match(tree, process(selector), transformCases(cases)))
+          }
 
         // a synthetic object is a generated object, such as case class companion
         case m: ModuleDef if m.symbol.isSynthetic => super.transform(tree)
@@ -582,4 +589,3 @@ class ScoverageInstrumentationComponent(val global: Global)
   }
 }
 
-

src/test/scala/scoverage/PluginASTSupportTest.scala

@@ -65,7 +65,20 @@ class PluginASTSupportTest
     assert(!reporter.hasErrors)
   }
 
-//  test("scoverage supports skinny #23") {
+
+  // https://github.com/scoverage/scalac-scoverage-plugin/issues/32
+  test("exhaustive warnings should not be generated for @unchecked") {
+    compileCodeSnippet( """object PartialMatchObject {
+                          |  def partialMatchExample(s: Option[String]): Unit = {
+                          |    (s: @unchecked) match {
+                          |      case Some(str) => println(str)
+                          |    }
+                          |  }
+                          |} """.stripMargin)
+    assert(!reporter.hasWarnings)
+  }
+
+  //  test("scoverage supports skinny #23") {
 //    addToClassPath("org.joda", "joda-convert", "1.3.1")
 //    addToClassPath("joda-time", "joda-time", "2.3")
 //    addToClassPath("org.scalikejdbc", "scalikejdbc_2.10", "1.7.5")

src/test/scala/scoverage/PluginCoverageTest.scala

@@ -33,13 +33,24 @@ class PluginCoverageTest
     assertNMeasuredStatements(3)
   }
 
-
+  test("scoverage should instrument selectors in match") {
+    compileCodeSnippet( """ trait A {
+                          |  def foo(a:String) = (if (a == "hello") 1 else 2) match {
+                          |    case any => "yes"
+                          |  }
+                          |} """.stripMargin)
+    assert(!reporter.hasErrors)
+    // should instrument the method call, the if clause, thenp, thenp literal, elsep, elsep literal, case block,
+    // case block literal
+    assertNMeasuredStatements(8)
+  }
 
   // https://github.com/scoverage/sbt-scoverage/issues/16
   test("scoverage should instrument for-loops but not the generated default case") {
     compileCodeSnippet( """ trait A {
                           |  def print1(list: List[String]) = for (string: String <- list) println(string)
                           |} """.stripMargin)
+    assert(!reporter.hasErrors)
     // should have one statement for the withFilter invoke, one of the match selector,
     // one of the case block, one for the case string RHS value, one for the foreach block.
     assertNMeasuredStatements(5)
@@ -53,7 +64,9 @@ class PluginCoverageTest
                           |    case _ => 3
                           |  }
                           |} """.stripMargin)
+    assert(!reporter.hasErrors)
     // should have one statement for each literal, one for each case block, and one for the selector.
     assertNMeasuredStatements(7)
   }
+
 }