compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala

@@ -70,11 +70,12 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
       * ```
       * where DIR is the _outputPath_ defined by the coverage settings.
       */
-    private def invokeCall(id: Int, span: Span)(using Context): GenericApply =
+    private def invokeCall(id: Int, span: Span)(using Context): Apply =
       ref(defn.InvokedMethodRef).withSpan(span)
         .appliedToArgs(
           Literal(Constant(id)) :: Literal(ConstOutputPath) :: Nil
         ).withSpan(span)
+        .asInstanceOf[Apply]
 
     /**
       * Records information about a new coverable statement. Generates a unique id for it.
@@ -119,7 +120,7 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
     private def createInvokeCall(tree: Tree, pos: SourcePosition, branch: Boolean = false)(using Context): Apply =
       val statementId = recordStatement(tree, pos, branch)
       val span = pos.span.toSynthetic
-      invokeCall(statementId, span).asInstanceOf[Apply]
+      invokeCall(statementId, span)
 
     /**
       * Tries to instrument an `Apply`.
@@ -364,9 +365,10 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
           // args are types, instrument the fun with transformParent
           cpy.TypeApply(tree)(transformParent(tree.fun), tree.args)
         case other =>
-          transform(other)
+          // should always be a TypeTree, nothing to instrument
+          other
 
-      parents.map(transformParent)
+      parents.mapConserve(transformParent)
 
     /** Instruments the body of a DefDef. Handles corner cases.
      * Given a DefDef f like this:
@@ -508,7 +510,7 @@ object InstrumentCoverage:
    * @param invokeCall call to Invoker.invoked(dir, id), or an empty tree.
    * @param expr the instrumented expression, executed just after the invokeCall
    */
-  case class InstrumentedParts(pre: List[Tree], invokeCall: Apply | Thicket, expr: Tree):
+  case class InstrumentedParts(pre: List[Tree], invokeCall: Apply | EmptyTree.type, expr: Tree):
     require(pre.isEmpty || (pre.nonEmpty && !invokeCall.isEmpty), "if pre isn't empty then invokeCall shouldn't be empty")
 
     /** Turns this into an actual Tree. */
@@ -517,10 +519,6 @@ object InstrumentCoverage:
       else if pre.isEmpty then Block(invokeCall :: Nil, expr)
       else Block(pre :+ invokeCall, expr)
 
-    /** Applies a function on the instrumented expression. */
-    def map(f: Tree => Tree): InstrumentedParts =
-      InstrumentedParts(pre, invokeCall, f(expr))
-
   object InstrumentedParts:
     def notCovered(expr: Tree) = InstrumentedParts(Nil, EmptyTree, expr)
     def singleExpr(invokeCall: Apply, expr: Tree) = InstrumentedParts(Nil, invokeCall, expr)