Make coverage instrumentation more robust

[TheElectronWill]

As with the last coverage PR, don't worry: most of the changes are "expect" files for tests. On top of that, many files have only changed by the order in which the statements are recorded, but this order doesn't matter.

Small changes which, together, make the instrumentation more robust and fix many bugs:

1. Address comments in Keep 'fun' and 'args' together when instrumenting TypeApply for coverage #15739 by introducing a type InstrumentedParts. The initial problem was that TypeApply cannot be instrumented in a straightforward way: expr[T] cannot be turned into {invoked(...); expr}[T] but must be {invoked(...); expr[T]}. To do this, we first try to instrument expr and then, if it was successfully instrumented, we move the call to invoked(...) to the right place. This gives us the following code in transform:

case TypeApply(fun, args) =>
  val InstrumentedParts(pre, coverageCall, expr) = tryInstrument(fun) // may generate a call to invoked(...), but it's not part of the resulting tree yet
  if coverageCall.isEmpty then
    tree
  else
    Block(
      pre :+ coverageCall, // put the call at the right place (pre contains lifted definitions, if any)
      cpy.TypeApply(tree)(expr, args)
  )

2. Exclude more trees from instrumentation, like Erased trees and calls to the parents' constructor in Template#parents.
3. Escape special characters in Serializer.
4. Reposition Inlined trees to the current source in order to avoid referencing an unreachable compilation unit. This might be the most controversial change because I've called Inlines.dropInlined 👀. Any suggestion is welcome!

[smarter]

Otherwise LGTM!

[smarter]

Isn't tree.call kept as-is by PostTyper? What information are we losing that affects the coverage report exactly?

[TheElectronWill]

PostTyper replaces the call tree by a "call trace", see PostTyper:362. The doc of Inlined explains:

@param  call      Info about the original call that was inlined.
Until PostTyper, this is the full call, afterwards only
a reference to the toplevel class from which the call was inlined.

I don't know why it's like this, but the consequence is that for instrumentCoverage, tree.call only contains the toplevel class, not the original inlined call. Therefore, we lose the name of the method (or val) that was inlined.

[TheElectronWill]

Ideally, for:

assert(x) // inline def in Predef

we would report that assert was called, but that's not possible for the moment.

[smarter]

ah yeah that's right, I think it's just an optimization, in particular it reduces the amount of stuff we store in the tasty files, but if it negatively affects the coverage checking report maybe this could be revisited.

[TheElectronWill]

Ah, we got hit by Windows path separator again :(
#16245