Implement reflection based dataprovider detection

Author: staabm

extension.neon

@@ -49,6 +49,12 @@ services:
 		class: PHPStan\Rules\PHPUnit\CoversHelper
 	-
 		class: PHPStan\Rules\PHPUnit\AnnotationHelper
+
+	-
+		class: PHPStan\Rules\PHPUnit\TestMethodsHelper
+		arguments:
+			parser: @defaultAnalysisParser
+
 	-
 		class: PHPStan\Rules\PHPUnit\PHPUnitVersionDetector
 

src/Rules/PHPUnit/DataProviderDataRule.php

@@ -17,11 +17,15 @@ class DataProviderDataRule implements Rule
 {
 	private ReflectionProvider $reflectionProvider;
 
+	private TestMethodsHelper $testMethodsHelper;
+
 	public function __construct(
 		ReflectionProvider $reflectionProvider,
+		TestMethodsHelper $testMethodsHelper,
 	)
 	{
 		$this->reflectionProvider = $reflectionProvider;
+		$this->testMethodsHelper = $testMethodsHelper;
 	}
 
 	public function getNodeType(): string
@@ -58,7 +62,22 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
-		// XXX check whether the method is used as a data provider
+		$testsWithProvider = [];
+		$testMethods = $this->testMethodsHelper->getTestMethods($classReflection);
+		foreach($testMethods as $testMethod)
+		{
+			foreach($this->testMethodsHelper->getDataProviderMethods($scope, $testMethod, $classReflection) as [$providerMethod])
+			{
+				if ($providerMethod === $method->getName()) {
+					$testsWithProvider[] = $testMethod;
+					continue 2;
+				}
+			}
+		}
+
+		if (count($testsWithProvider) === 0) {
+			return [];
+		}
 
 		foreach($node->expr->items as $item) {
 			if (!$item->value instanceof Node\Expr\Array_) {
@@ -69,7 +88,7 @@ public function processNode(Node $node, Scope $scope): array
 			$var = new Node\Expr\New_(new Node\Name($classReflection->getName()));
 			$scope->invokeNodeCallback(new Node\Expr\MethodCall(
 				$var,
-				'testTrim',
+				$testsWithProvider[0]->getName(),
 				$args,
 				['startLine' => $item->getStartLine()]
 			));

src/Rules/PHPUnit/TestMethodsHelper.php

@@ -0,0 +1,113 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PHPUnit;
+
+use PhpParser\Node;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\ClassMethod;
+use PHPStan\Parser\Parser;
+use PHPStan\PhpDoc\ResolvedPhpDocBlock;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\FileTypeMapper;
+use ReflectionMethod;
+use function array_merge;
+use function explode;
+use function sprintf;
+use function strpos;
+
+final class TestMethodsHelper
+{
+	private ReflectionProvider $reflectionProvider;
+
+	private FileTypeMapper $fileTypeMapper;
+
+	private Parser $parser;
+
+	public function __construct(
+		ReflectionProvider $reflectionProvider,
+		FileTypeMapper $fileTypeMapper,
+		Parser $parser
+	)
+	{
+		$this->reflectionProvider = $reflectionProvider;
+		$this->fileTypeMapper = $fileTypeMapper;
+		$this->parser = $parser;
+	}
+
+	/**
+	 * @return array<ReflectionMethod>
+	 */
+	public function getTestMethods(ClassReflection $class): array
+	{
+		$testMethods = [];
+		foreach($class->getNativeReflection()->getMethods() as $reflectionMethod) {
+			if (str_starts_with(strtolower($reflectionMethod->getName()), 'test')) {
+				$testMethods[] = $reflectionMethod;
+				continue;
+			}
+
+			// todo: detect tests with @test annotation
+
+			$testAttributes = $reflectionMethod->getAttributes('PHPUnit\Framework\Attribute\Test');
+			if ($testAttributes !== []) {
+				$testMethods[] = $reflectionMethod;
+			}
+		}
+
+		return $testMethods;
+	}
+
+	/**
+	 * @return iterable<array{string}>
+	 */
+	public function getDataProviderMethods(
+		Scope                            $scope,
+		ReflectionMethod $node,
+		ClassReflection                  $classReflection
+	): iterable
+	{
+		/*
+		$docComment = $node->getDocComment();
+		if ($docComment !== null) {
+			$methodPhpDoc = $this->fileTypeMapper->getResolvedPhpDoc(
+				$scope->getFile(),
+				$classReflection->getName(),
+				$scope->isInTrait() ? $scope->getTraitReflection()->getName() : null,
+				$node->name->toString(),
+				$docComment->getText(),
+			);
+			foreach ($this->getDataProviderAnnotations($methodPhpDoc) as $annotation) {
+				$dataProviderValue = $this->getDataProviderAnnotationValue($annotation);
+				if ($dataProviderValue === null) {
+					// Missing value is already handled in NoMissingSpaceInMethodAnnotationRule
+					continue;
+				}
+
+				$dataProviderMethod = $this->parseDataProviderAnnotationValue($scope, $dataProviderValue);
+				$dataProviderMethod[] = $node->getStartLine();
+
+				yield $dataProviderValue => $dataProviderMethod;
+			}
+		}
+
+		if (!$this->phpunit10OrNewer) {
+			return;
+		}
+		*/
+
+		foreach ($node->getAttributes('PHPUnit\Framework\Attributes\DataProvider') as $attr) {
+			$args = $attr->getArguments();
+			if (count($args) !== 1) {
+				continue;
+			}
+
+			yield [$args[0]];
+		}
+	}
+
+}

tests/Rules/PHPUnit/DataProviderDataRuleTest.php

@@ -10,10 +10,12 @@
 use PHPStan\Rules\NullsafeCheck;
 use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
 use PHPStan\Rules\PHPUnit\DataProviderDataRule;
+use PHPStan\Rules\PHPUnit\TestMethodsHelper;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\FileTypeMapper;
 
 /**
  * @extends RuleTestCase<DataProviderDataRule>
@@ -30,7 +32,8 @@ protected function getRule(): Rule
 
 		return new CompositeRule(new DirectRegistry([
 			new DataProviderDataRule(
-				$reflectionProvider
+				$reflectionProvider,
+				new TestMethodsHelper($reflectionProvider, self::getContainer()->getByType(FileTypeMapper::class), self::getContainer()->getService('defaultAnalysisParser'))
 			),
 			new CallMethodsRule(
 				new MethodCallCheck($reflectionProvider, $ruleLevelHelper, true, true),