Code that is optimized out is considered coverable but never covered

[Hixie]

lib/foo.dart:

class Test {
  Test(
  ) : assert(true),
      _a = 1,
      assert(true) {
    _a = 2;
  }

  int _a;
}

pubspec.yaml:

name: foo
dependencies:
  test: any
environment:
  sdk: '>2.12.0'

test/test_test.dart:

import 'package:test/test.dart';
import 'package:foo/foo.dart';

void main() {
  test('', () { Test(); });
}

Collect coverage however you wish, I used this:

$ flutter test --coverage
$ genhtml coverage/lcov.info

Expected result: 100% coverage.
Actual result: 50% coverage. Specifically:

class Test {
  Test( // COVERED
  ) : assert(true),  // NOT COVERED
      _a = 1,
      assert(true) { // NOT COVERED
    _a = 2; // COVERED
  }

  int _a;
}

In other words, asserts in constructors count against coverage. This seems suboptimal and is dragging down our coverage numbers over here in Flutter land because some of our libraries with 100% coverage actually score less than that and the only lines that aren't covered are the asserts.

[Hixie]

I wonder if what's going on here is that asserts that are always true are marked as not covered, but are still marked as runnable code. It makes sense that they not count towards coverage (they're redundant no-op code), but in that case they should be marked as not coverable as well.

FWIW, this is actually making it quite hard for me to improve the coverage for Flutter because so many of our "uncovered" lines are things like this, where there's an assert that's optimized out and gets marked as untested.

[lrhn]

It would make sense if asserts didn't count towards coverage when assertions are disabled.

It's slightly tricky for const constructor assertions since they are always executed during const evaluation. I don't know how const evaluation counts towards coverage in general.

[Hixie]

As far as I can tell what's actually going on is that the asserts (and other code, I don't think it's strictly only asserts) that the compiler can prove are always true (or are always dead code) are being optimised out, but still count towards code that could be covered, and thus end up as "uncovered" code in the coverage results.

Code that's optimized out should just count as uncoverable, like blank lines or comments.

cc @liamappelbe

[liamappelbe]

I think this bug is the same underlying issue as #47017. Asserts just weren't having their coverage tracked properly. Should be fixed now.

[Hixie]

woot! thanks @liamappelbe!