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,246 @@
+<?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 const PHP_INT_MAX;
+
+/**
+ * @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 = $testsWithProvider[0]->getNumberOfParameters();
+if (count($testsWithProvider) > 1) {
+foreach ($testsWithProvider as $testMethod) {
+if ($testMethod->isVariadic()) {
+$maxNumberOfParameters = PHP_INT_MAX;
+break;
+}
+
+$maxNumberOfParameters = max($maxNumberOfParameters, $testMethod->getNumberOfParameters());
+}
+}
+
+foreach ($testsWithProvider as $testMethod) {
+$numberOfParameters = $testMethod->getNumberOfParameters();
+
+foreach ($arraysTypes as [$startLine, $arraysType]) {
+$args = $this->arrayItemsToArgs($arraysType, $maxNumberOfParameters);
+if ($args === null) {
+continue;
+}
+
+if (
+!$testMethod->isVariadic()
+&& $numberOfParameters !== $maxNumberOfParameters
+) {
+$args = array_slice($args, 0, $numberOfParameters);
+}
+
+$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;
+}
+
+}