minor #39644 [PhpUnitBridge] Modernize CoverageListener (derrabus)

This PR was merged into the 5.3-dev branch.

Discussion
----------

[PhpUnitBridge] Modernize CoverageListener

| Q             | A
| ------------- | ---
| Branch?       | 5.x
| Bug fix?      | no
| New feature?  | no
| Deprecations? | no
| Tickets       | N/A
| License       | MIT
| Doc PR        | N/A

This PR proposes to merge `CoverageListener`, `CoverageListenerForV7` and `CoverageListenerTrait` into a single class because we don't have to deal with multiple implementations anymore.

Additionally, I've removed compat code for PHPUnit < 7.5 and added type declarations where possible.

Commits
-------

eb1669069b [PhpUnitBridge] Modernize CoverageListener

Author: nicolas-grekas

CoverageListener.php

@@ -11,10 +11,109 @@
 
 namespace Symfony\Bridge\PhpUnit;
 
-class_alias('Symfony\Bridge\PhpUnit\Legacy\CoverageListenerForV7', 'Symfony\Bridge\PhpUnit\CoverageListener');
+use PHPUnit\Framework\Test;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\TestListener;
+use PHPUnit\Framework\TestListenerDefaultImplementation;
+use PHPUnit\Framework\Warning;
+use PHPUnit\Util\Annotation\Registry;
+use PHPUnit\Util\Test as TestUtil;
 
-if (false) {
-    class CoverageListener
+class CoverageListener implements TestListener
+{
+    use TestListenerDefaultImplementation;
+
+    private $sutFqcnResolver;
+    private $warningOnSutNotFound;
+
+    public function __construct(callable $sutFqcnResolver = null, bool $warningOnSutNotFound = false)
+    {
+        $this->sutFqcnResolver = $sutFqcnResolver ?? static function (Test $test): ?string {
+            $class = \get_class($test);
+
+            $sutFqcn = str_replace('\\Tests\\', '\\', $class);
+            $sutFqcn = preg_replace('{Test$}', '', $sutFqcn);
+
+            return class_exists($sutFqcn) ? $sutFqcn : null;
+        };
+
+        $this->warningOnSutNotFound = $warningOnSutNotFound;
+    }
+
+    public function startTest(Test $test): void
     {
+        if (!$test instanceof TestCase) {
+            return;
+        }
+
+        $annotations = TestUtil::parseTestMethodAnnotations(\get_class($test), $test->getName(false));
+
+        $ignoredAnnotations = ['covers', 'coversDefaultClass', 'coversNothing'];
+
+        foreach ($ignoredAnnotations as $annotation) {
+            if (isset($annotations['class'][$annotation]) || isset($annotations['method'][$annotation])) {
+                return;
+            }
+        }
+
+        $sutFqcn = ($this->sutFqcnResolver)($test);
+        if (!$sutFqcn) {
+            if ($this->warningOnSutNotFound) {
+                $test->getTestResultObject()->addWarning($test, new Warning('Could not find the tested class.'), 0);
+            }
+
+            return;
+        }
+
+        $covers = $sutFqcn;
+        if (!\is_array($sutFqcn)) {
+            $covers = [$sutFqcn];
+            while ($parent = get_parent_class($sutFqcn)) {
+                $covers[] = $parent;
+                $sutFqcn = $parent;
+            }
+        }
+
+        if (class_exists(Registry::class)) {
+            $this->addCoversForDocBlockInsideRegistry($test, $covers);
+
+            return;
+        }
+
+        $this->addCoversForClassToAnnotationCache($test, $covers);
+    }
+
+    private function addCoversForClassToAnnotationCache(Test $test, array $covers): void
+    {
+        $r = new \ReflectionProperty(TestUtil::class, 'annotationCache');
+        $r->setAccessible(true);
+
+        $cache = $r->getValue();
+        $cache = array_replace_recursive($cache, [
+            \get_class($test) => [
+                'covers' => $covers,
+            ],
+        ]);
+
+        $r->setValue(TestUtil::class, $cache);
+    }
+
+    private function addCoversForDocBlockInsideRegistry(Test $test, array $covers): void
+    {
+        $docBlock = Registry::getInstance()->forClassName(\get_class($test));
+
+        $symbolAnnotations = new \ReflectionProperty($docBlock, 'symbolAnnotations');
+        $symbolAnnotations->setAccessible(true);
+
+        // Exclude internal classes; PHPUnit 9.1+ is picky about tests covering, say, a \RuntimeException
+        $covers = array_filter($covers, function (string $class) {
+            $reflector = new \ReflectionClass($class);
+
+            return $reflector->isUserDefined();
+        });
+
+        $symbolAnnotations->setValue($docBlock, array_replace($docBlock->symbolAnnotations(), [
+            'covers' => $covers,
+        ]));
     }
 }

Legacy/CoverageListenerForV7.php

@@ -12,6 +12,4 @@
 require __DIR__.'/../src/BarCov.php';
 require __DIR__.'/../src/FooCov.php';
 
-require __DIR__.'/../../../../Legacy/CoverageListenerTrait.php';
-require_once __DIR__.'/../../../../Legacy/CoverageListenerForV7.php';
 require __DIR__.'/../../../../CoverageListener.php';