Coverage instrumentation of unit tests also instruments a closure added by #[test]

[Zalathar]

Consider this source file from the coverage test suite:

rust/tests/coverage/test_harness.rs

Lines 9 to 10 in 6bf600b

	#[test]
	fn my_test() {}

When we instrument this file for coverage, we generate coverage mappings for my_test as expected. However, we also generate coverage mappings for a mysterious closure inside my_test:

rust/tests/coverage/test_harness.cov-map

Lines 9 to 15 in 6bf600b

	Function name: test_harness::my_test::{closure#0}
	Raw bytes (9): 0x[01, 01, 00, 01, 01, 09, 01, 00, 08]
	Number of files: 1
	- file 0 => global file 1
	Number of expressions: 0
	Number of file 0 mappings: 1
	- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 8)

This closure turns out to have been added by the builtin macro that expands #[test] attributes.

Adding coverage instrumentation to this closure is not useful, and we should not be doing it.

---

Right now this only causes minor problems in the final coverage reports, because coverage for the closure shows up on its own line with the span of the attribute. But while working on some other changes to how we handle macro-expanded closure bodies, I found that some of my changes had the side-effect of causing these test closures to show up and start interfering with the reports.

We should have some way for the coverage instrumentor to know that it should ignore closures introduced by #[test] attributes, and not instrument them at all.

[Zalathar]

@rustbot label +A-code-coverage

In theory the correct way to handle this is to have the builtin #[test] macro add the #[coverage(off)] attribute to the closure it introduces. I tried implementing that, but it turned out to be a bit tricky, which is why I ended up filing this issue instead of a PR to fix it.

Another less-pleasing but more immediately practical option would be to have better heuristics that would detect and discard this sort of closure. The trick is finding something that does the job without also negatively impacting real user code that uses macros.