Lines of multiline ternary expressions inside array literals are not shown in coverage reports

[mvorisek]

Q	A
php-code-coverage version	10.1.11
PHP version	8.3.0
Driver	Xdebug
PCOV version (if used)	n/a
Xdebug version (if used)	3.3.1
Installation Method	Composer
Usage Method	PHPUnit
PHPUnit version (if used)	10.5.9

repro code: https://github.com/atk4/data/blob/9e46bc827f/src/Reference/ContainsOne.php#L20

https://app.codecov.io/gh/atk4/data/pull/1158/blob/src/Reference/ContainsOne.php#L20

Expected behaviour:

Both false/true ternary (and also null coalescing branch of null coalescing operator) must be measured.

In the screenshot above, the l20 must be either green or red.

[sebastianbergmann]

When processing coverage data, FilterProcessor::applyExecutableLinesFilter() reconciles two sources of truth: the raw line coverage data reported by, for example, Xdebug at runtime and the set of executable lines identified by static analysis of the source code (via ExecutableLinesFindingVisitor).

Previously, the method performed two steps:

1. keepLineCoverageDataOnlyForLines() intersects the runtime-reported lines with the statically identified executable lines, discarding lines that static analysis does not consider executable.
2. markExecutableLineByBranch() propagates the coverage status of any executed line to all other lines within the same branch, so that multiline expressions within a single branch share coverage status.

The problem is that step 1 is a pure intersection: it can only retain lines that Xdebug, for example, already reported. It cannot add lines that static analysis identified as executable but that Xdebug did not report at all. When a multiline ternary operator appears inside an array literal, PHP's compiler maps the opcodes for the branch expressions to the condition's line rather than to their own source lines. Xdebug reports the line numbers that PHP assigns to opcodes (it does not assign line numbers itself), so it never reports the branch expression lines in its coverage data. After step 1, these lines are simply absent and they appear in coverage reports neither as covered nor as uncovered.

The fix adds a new step between the existing two:

1. keepLineCoverageDataOnlyForLines() remains unchanged, filters to known executable lines.
2. addMissingExecutableLines() is a new step that inserts an entry with status LINE_NOT_EXECUTED for every line that static analysis identified as executable but that is not present in the (now filtered) Xdebug data.
3. markExecutableLineByBranch() remains unchanged, propagates coverage within branches.

This ensures that lines the static analysis knows to be executable always appear in the coverage data, even when PHP's opcode-to-line mapping does not match the source layout. In the case described here, the branch expression lines of a multiline ternary inside an array literal will now appear as uncovered (red) rather than being invisible.

Because PHP's compiler maps these opcodes to the condition's line, even when the false branch of such a ternary is taken at runtime, the coverage driver does not report the false-branch line as executed, so the line will still appear red in that case. If PHP's compiler is changed to preserve the original source line numbers for these opcodes, the existing markExecutableLineByBranch() step will correctly propagate the executed status and no further changes will be needed here.

[derickr]

Due to a bug in Xdebug (reported as https://bugs.xdebug.org/view.php?id=2419)

That is incorrect. Xdebug does not add line numbers to opcodes.

[sebastianbergmann]

I should not have mistaken a shortcoming in PHP's compiler for a bug in Xdebug. I have updated the description above accordingly. Thank you, @derickr, for correcting me.