#90 Fixed unwanted instrumenting of tuple wrapping in functions

Author: sksamuel

scalac-scoverage-plugin/src/main/scala/scoverage/plugin.scala

@@ -50,7 +50,6 @@ class ScoverageOptions {
   var dataDir: String = File.createTempFile("scoverage_datadir_not_defined", ".tmp").getParent
 }
 
-
 class ScoverageInstrumentationComponent(val global: Global)
   extends PluginComponent
   with TypingTransformers
@@ -324,6 +323,11 @@ class ScoverageInstrumentationComponent(val global: Global)
         // ignore macro definitions in 2.11
         case DefDef(mods, _, _, _, _, _) if mods.isMacro => tree
 
+        case d: DefDef =>
+          println(d)
+          val e = d
+          d
+
         // this will catch methods defined as macros, eg def test = macro testImpl
         // it will not catch macro implemenations
         case d: DefDef if d.symbol != null
@@ -431,7 +435,10 @@ class ScoverageInstrumentationComponent(val global: Global)
             treeCopy
               .Match(tree, instrument(selector, selector), transformCases(cases.dropRight(1)) ++ cases.takeRight(1))
           } else {
-            treeCopy.Match(tree, process(selector), transformCases(cases))
+            if (selector.symbol.isSynthetic)
+              treeCopy.Match(tree, selector, transformCases(cases))
+            else
+              treeCopy.Match(tree, process(selector), transformCases(cases))
           }
 
         // a synthetic object is a generated object, such as case class companion
@@ -534,18 +541,24 @@ class ScoverageInstrumentationComponent(val global: Global)
         /**
          * We can ignore lazy val defs as they are implemented by a generated defdef
          */
-        case v: ValDef if v.symbol.isLazy => tree
+        case v: ValDef if v.symbol.isLazy =>
+          val w = v
+          tree
 
         /**
          * <synthetic> val default: A1 => B1 =
          * <synthetic> val x1: Any = _
          */
-        case v: ValDef if v.symbol.isSynthetic => tree
+        case v: ValDef if v.symbol.isSynthetic =>
+          val w = v
+          tree
 
         /**
          * Vals declared in case constructors
          */
-        case v: ValDef if v.symbol.isParamAccessor && v.symbol.isCaseAccessor => tree
+        case v: ValDef if v.symbol.isParamAccessor && v.symbol.isCaseAccessor =>
+          val w = v
+          tree
 
         // we need to remove the final mod so that we keep the code in order to check its invoked
         case v: ValDef if v.mods.isFinal =>

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

@@ -62,8 +62,7 @@ class PluginASTSupportTest
     assert(!compiler.reporter.hasErrors)
   }
 
-
-  // https://github.com/scoverage/scalac-scoverage-plugin/issues/32
+ // https://github.com/scoverage/scalac-scoverage-plugin/issues/32
   test("exhaustive warnings should not be generated for @unchecked") {
     val compiler = ScoverageCompiler.default
     compiler.compileCodeSnippet( """object PartialMatchObject {

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

@@ -159,6 +159,30 @@ class PluginCoverageTest
     compiler.assertNMeasuredStatements(1)
   }
 
+  test("scoverage should not instrument function tuple wrapping") {
+    val compiler = ScoverageCompiler.default
+    compiler.compileCodeSnippet(
+      """
+        |    sealed trait Foo
+        |    case class Bar(s: String) extends Foo
+        |    case object Baz extends Foo
+        |
+        |    object Foo {
+        |      implicit val fooOrdering: Ordering[Foo] = Ordering.fromLessThan {
+        |        case (Bar(_), Baz) => true
+        |        case (Bar(a), Bar(b)) => a < b
+        |        case (_, _) => false
+        |      }
+        |    }
+      """.stripMargin)
+
+    assert(!compiler.reporter.hasErrors)
+    assert(!compiler.reporter.hasWarnings)
+    // should have 4 profiled statements: the outer apply, the true, the a < b, the false
+    // we are testing that we don't instrument the tuple2 call used here
+    compiler.assertNMeasuredStatements(4)
+  }
+
   test("scoverage should instrument all case statements in an explicit match") {
     val compiler = ScoverageCompiler.default
     compiler.compileCodeSnippet( """ trait A {

scalac-scoverage-runtime/src/main/scala/scoverage/Invoker.scala

@@ -40,7 +40,7 @@ object Invoker {
       var files = threadFiles.get()
       if (files == null)
         files = TrieMap.empty[String, FileWriter]
-        threadFiles.set(files)
+      threadFiles.set(files)
 
       val writer = files.getOrElseUpdate(dataDir, new FileWriter(measurementFile(dataDir), true))
       writer.append(id.toString + '\n').flush()