Implement DataProviderDataRule

composer.json

@@ -7,7 +7,7 @@
 	],
 	"require": {
 		"php": "^7.4 || ^8.0",
-		"phpstan/phpstan": "^2.1.18"
+		"phpstan/phpstan": "^2.1.32"
 	},
 	"conflict": {
 		"phpunit/phpunit": "<7.0"

extension.neon

@@ -49,9 +49,16 @@ services:
 		class: PHPStan\Rules\PHPUnit\CoversHelper
 	-
 		class: PHPStan\Rules\PHPUnit\AnnotationHelper
+
 	-
 		class: PHPStan\Rules\PHPUnit\PHPUnitVersionDetector
 
+	-
+		class: PHPStan\Rules\PHPUnit\TestMethodsHelper
+		factory: @PHPStan\Rules\PHPUnit\TestMethodsHelperFactory::create()
+	-
+		class: PHPStan\Rules\PHPUnit\TestMethodsHelperFactory
+
 	-
 		class: PHPStan\Rules\PHPUnit\DataProviderHelper
 		factory: @PHPStan\Rules\PHPUnit\DataProviderHelperFactory::create()

rules.neon

@@ -13,6 +13,9 @@ conditionalTags:
 	PHPStan\Rules\PHPUnit\AssertEqualsIsDiscouragedRule:
 		phpstan.rules.rule: [%strictRulesInstalled%, %featureToggles.bleedingEdge%]
 
+	PHPStan\Rules\PHPUnit\DataProviderDataRule:
+		phpstan.rules.rule: %featureToggles.bleedingEdge%
+
 services:
 	-
 		class: PHPStan\Rules\PHPUnit\DataProviderDeclarationRule
@@ -24,3 +27,6 @@ services:
 
 	-
 		class: PHPStan\Rules\PHPUnit\AssertEqualsIsDiscouragedRule
+
+	-
+		class: PHPStan\Rules\PHPUnit\DataProviderDataRule

src/Rules/PHPUnit/DataProviderDataRule.php

@@ -0,0 +1,237 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PHPUnit;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\Expr\TypeExpr;
+use PHPStan\Rules\Rule;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPUnit\Framework\TestCase;
+use function array_slice;
+use function count;
+use function max;
+use function min;
+
+/**
+ * @implements Rule<Node>
+ */
+class DataProviderDataRule implements Rule
+{
+
+	private TestMethodsHelper $testMethodsHelper;
+
+	private DataProviderHelper $dataProviderHelper;
+
+	public function __construct(
+		TestMethodsHelper $testMethodsHelper,
+		DataProviderHelper $dataProviderHelper
+	)
+	{
+		$this->testMethodsHelper = $testMethodsHelper;
+		$this->dataProviderHelper = $dataProviderHelper;
+	}
+
+	public function getNodeType(): string
+	{
+		return Node::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (
+			!$node instanceof Node\Stmt\Return_
+			&& !$node instanceof Node\Expr\Yield_
+			&& !$node instanceof Node\Expr\YieldFrom
+		) {
+			return [];
+		}
+
+		if ($scope->getFunction() === null) {
+			return [];
+		}
+		if ($scope->isInAnonymousFunction()) {
+			return [];
+		}
+
+		$arraysTypes = $this->buildArrayTypesFromNode($node, $scope);
+		if ($arraysTypes === []) {
+			return [];
+		}
+
+		$method = $scope->getFunction();
+		$classReflection = $scope->getClassReflection();
+		if (
+			$classReflection === null
+			|| !$classReflection->is(TestCase::class)
+		) {
+			return [];
+		}
+
+		$testsWithProvider = [];
+		$testMethods = $this->testMethodsHelper->getTestMethods($classReflection, $scope);
+		foreach ($testMethods as $testMethod) {
+			foreach ($this->dataProviderHelper->getDataProviderMethods($scope, $testMethod, $classReflection) as [, $providerMethodName]) {
+				if ($providerMethodName === $method->getName()) {
+					$testsWithProvider[] = $testMethod;
+					continue 2;
+				}
+			}
+		}
+
+		if (count($testsWithProvider) === 0) {
+			return [];
+		}
+
+		$maxNumberOfParameters = 0;
+		$trimArgs = count($testsWithProvider) > 1;
+		foreach ($testsWithProvider as $testMethod) {
+			$maxNumberOfParameters = max($maxNumberOfParameters, $testMethod->getNumberOfParameters());
+		}
+
+		foreach ($testsWithProvider as $testMethod) {
+			$numberOfParameters = $testMethod->getNumberOfParameters();
+
+			foreach ($arraysTypes as [$startLine, $arraysType]) {
+				$args = $this->arrayItemsToArgs($arraysType, $numberOfParameters);
+				if ($args === null) {
+					continue;
+				}
+
+				if ($trimArgs && $maxNumberOfParameters !== $numberOfParameters) {
+					$args = array_slice($args, 0, min($numberOfParameters, $maxNumberOfParameters));
+				}
+
+				$scope->invokeNodeCallback(new Node\Expr\MethodCall(
+					new TypeExpr(new ObjectType($classReflection->getName())),
+					$testMethod->getName(),
+					$args,
+					['startLine' => $startLine],
+				));
+			}
+		}
+
+		return [];
+	}
+
+	/**
+	 * @return array<Node\Arg>
+	 */
+	private function arrayItemsToArgs(Type $array, int $numberOfParameters): ?array
+	{
+		$args = [];
+
+		$constArrays = $array->getConstantArrays();
+		if ($constArrays !== [] && count($constArrays) === 1) {
+			$keyTypes = $constArrays[0]->getKeyTypes();
+			$valueTypes = $constArrays[0]->getValueTypes();
+		} elseif ($array->isArray()->yes()) {
+			$keyTypes = [];
+			$valueTypes = [];
+			for ($i = 0; $i < $numberOfParameters; ++$i) {
+				$keyTypes[$i] = $array->getIterableKeyType();
+				$valueTypes[$i] = $array->getIterableValueType();
+			}
+		} else {
+			return null;
+		}
+
+		foreach ($valueTypes as $i => $valueType) {
+			$key = $keyTypes[$i]->getConstantStrings();
+			if (count($key) > 1) {
+				return null;
+			}
+
+			if (count($key) === 0) {
+				$arg = new Node\Arg(new TypeExpr($valueType));
+				$args[] = $arg;
+				continue;
+
+			}
+
+			$arg = new Node\Arg(
+				new TypeExpr($valueType),
+				false,
+				false,
+				[],
+				new Node\Identifier($key[0]->getValue()),
+			);
+			$args[] = $arg;
+		}
+
+		return $args;
+	}
+
+	/**
+	 * @param Node\Stmt\Return_|Node\Expr\Yield_|Node\Expr\YieldFrom $node
+	 *
+	 * @return list<list{int, Type}>
+	 */
+	private function buildArrayTypesFromNode(Node $node, Scope $scope): array
+	{
+		$arraysTypes = [];
+
+		// special case for providers only containing static data, so we get more precise error lines
+		if (
+			($node instanceof Node\Stmt\Return_ && $node->expr instanceof Node\Expr\Array_)
+			|| ($node instanceof Node\Expr\YieldFrom && $node->expr instanceof Node\Expr\Array_)
+		) {
+			foreach ($node->expr->items as $item) {
+				if (!$item->value instanceof Node\Expr\Array_) {
+					$arraysTypes = [];
+					break;
+				}
+
+				$constArrays = $scope->getType($item->value)->getConstantArrays();
+				if ($constArrays === []) {
+					$arraysTypes = [];
+					break;
+				}
+
+				foreach ($constArrays as $constArray) {
+					$arraysTypes[] = [$item->value->getStartLine(), $constArray];
+				}
+			}
+
+			if ($arraysTypes !== []) {
+				return $arraysTypes;
+			}
+		}
+
+		// general case with less precise error message lines
+		if ($node instanceof Node\Stmt\Return_ || $node instanceof Node\Expr\YieldFrom) {
+			if ($node->expr === null) {
+				return [];
+			}
+
+			$exprType = $scope->getType($node->expr);
+			$exprConstArrays = $exprType->getConstantArrays();
+			foreach ($exprConstArrays as $constArray) {
+				foreach ($constArray->getValueTypes() as $valueType) {
+					foreach ($valueType->getConstantArrays() as $constValueArray) {
+						$arraysTypes[] = [$node->getStartLine(), $constValueArray];
+					}
+				}
+			}
+
+			if ($arraysTypes === []) {
+				foreach ($exprType->getIterableValueType()->getArrays() as $arrayType) {
+					$arraysTypes[] = [$node->getStartLine(), $arrayType];
+				}
+			}
+		} elseif ($node instanceof Node\Expr\Yield_) {
+			if ($node->value === null) {
+				return [];
+			}
+
+			$exprType = $scope->getType($node->value);
+			foreach ($exprType->getConstantArrays() as $constValueArray) {
+				$arraysTypes[] = [$node->getStartLine(), $constValueArray];
+			}
+		}
+
+		return $arraysTypes;
+	}
+
+}

src/Rules/PHPUnit/TestMethodsHelper.php

@@ -0,0 +1,94 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PHPUnit;
+
+use PHPStan\Analyser\Scope;
+use PHPStan\PhpDoc\ResolvedPhpDocBlock;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Type\FileTypeMapper;
+use ReflectionMethod;
+use function str_starts_with;
+use function strtolower;
+
+final class TestMethodsHelper
+{
+
+	private FileTypeMapper $fileTypeMapper;
+
+	private bool $phpunit10OrNewer;
+
+	public function __construct(
+		FileTypeMapper $fileTypeMapper,
+		bool $phpunit10OrNewer
+	)
+	{
+		$this->fileTypeMapper = $fileTypeMapper;
+		$this->phpunit10OrNewer = $phpunit10OrNewer;
+	}
+
+	/**
+	 * @return array<ReflectionMethod>
+	 */
+	public function getTestMethods(ClassReflection $classReflection, Scope $scope): array
+	{
+		$testMethods = [];
+		foreach ($classReflection->getNativeReflection()->getMethods() as $reflectionMethod) {
+			if (!$reflectionMethod->isPublic()) {
+				continue;
+			}
+
+			if (str_starts_with(strtolower($reflectionMethod->getName()), 'test')) {
+				$testMethods[] = $reflectionMethod;
+				continue;
+			}
+
+			$docComment = $reflectionMethod->getDocComment();
+			if ($docComment !== false) {
+				$methodPhpDoc = $this->fileTypeMapper->getResolvedPhpDoc(
+					$scope->getFile(),
+					$classReflection->getName(),
+					$scope->isInTrait() ? $scope->getTraitReflection()->getName() : null,
+					$reflectionMethod->getName(),
+					$docComment,
+				);
+
+				if ($this->hasTestAnnotation($methodPhpDoc)) {
+					$testMethods[] = $reflectionMethod;
+					continue;
+				}
+			}
+
+			if (!$this->phpunit10OrNewer) {
+				continue;
+			}
+
+			$testAttributes = $reflectionMethod->getAttributes('PHPUnit\Framework\Attributes\Test'); // @phpstan-ignore argument.type
+			if ($testAttributes === []) {
+				continue;
+			}
+
+			$testMethods[] = $reflectionMethod;
+		}
+
+		return $testMethods;
+	}
+
+	private function hasTestAnnotation(?ResolvedPhpDocBlock $phpDoc): bool
+	{
+		if ($phpDoc === null) {
+			return false;
+		}
+
+		$phpDocNodes = $phpDoc->getPhpDocNodes();
+
+		foreach ($phpDocNodes as $docNode) {
+			$tags = $docNode->getTagsByName('@test');
+			if ($tags !== []) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+}