Ignore missingType.iterableValue for data-providers

Author: staabm

extension.neon

@@ -1,6 +1,7 @@
 parameters:
 	phpunit:
 		convertUnionToIntersectionType: true
+		checkDataProviderData: %featureToggles.bleedingEdge%
 	additionalConstructors:
 		- PHPUnit\Framework\TestCase::setUp
 	earlyTerminatingMethodCalls:
@@ -24,6 +25,7 @@ parameters:
 parametersSchema:
 	phpunit: structure([
 		convertUnionToIntersectionType: bool()
+		checkDataProviderData: bool(),
 	])
 
 services:
@@ -67,6 +69,11 @@ services:
 		arguments:
 			parser: @defaultAnalysisParser
 
+	-
+		class: PHPStan\Type\PHPUnit\DataProviderReturnTypeIgnoreExtension
+
 conditionalTags:
 	PHPStan\PhpDoc\PHPUnit\MockObjectTypeNodeResolverExtension:
 		phpstan.phpDoc.typeNodeResolverExtension: %phpunit.convertUnionToIntersectionType%
+	PHPStan\Type\PHPUnit\DataProviderReturnTypeIgnoreExtension:
+		phpstan.ignoreErrorExtension: %phpunit.checkDataProviderData%

rules.neon

@@ -14,7 +14,7 @@ conditionalTags:
 		phpstan.rules.rule: [%strictRulesInstalled%, %featureToggles.bleedingEdge%]
 
 	PHPStan\Rules\PHPUnit\DataProviderDataRule:
-		phpstan.rules.rule: %featureToggles.bleedingEdge%
+		phpstan.rules.rule: %phpunit.checkDataProviderData%
 
 services:
 	-

src/Rules/PHPUnit/DataProviderDataRule.php

@@ -8,7 +8,6 @@
 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;
@@ -62,10 +61,7 @@ public function processNode(Node $node, Scope $scope): array
 
 		$method = $scope->getFunction();
 		$classReflection = $scope->getClassReflection();
-		if (
-			$classReflection === null
-			|| !$classReflection->is(TestCase::class)
-		) {
+		if ($classReflection === null) {
 			return [];
 		}
 

src/Rules/PHPUnit/DataProviderHelper.php

@@ -53,23 +53,23 @@ public function __construct(
 	}
 
 	/**
-	 * @param ReflectionMethod|ClassMethod $node
+	 * @param ReflectionMethod|ClassMethod $testMethod
 	 *
 	 * @return iterable<array{ClassReflection|null, string, int}>
 	 */
 	public function getDataProviderMethods(
 		Scope $scope,
-		$node,
+		$testMethod,
 		ClassReflection $classReflection
 	): iterable
 	{
-		yield from $this->yieldDataProviderAnnotations($node, $scope, $classReflection);
+		yield from $this->yieldDataProviderAnnotations($testMethod, $scope, $classReflection);
 
 		if (!$this->phpunit10OrNewer) {
 			return;
 		}
 
-		yield from $this->yieldDataProviderAttributes($node, $classReflection);
+		yield from $this->yieldDataProviderAttributes($testMethod, $classReflection);
 	}
 
 	/**

src/Rules/PHPUnit/TestMethodsHelper.php

@@ -6,6 +6,7 @@
 use PHPStan\PhpDoc\ResolvedPhpDocBlock;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Type\FileTypeMapper;
+use PHPUnit\Framework\TestCase;
 use ReflectionMethod;
 use function str_starts_with;
 use function strtolower;
@@ -31,6 +32,10 @@ public function __construct(
 	 */
 	public function getTestMethods(ClassReflection $classReflection, Scope $scope): array
 	{
+		if (!$classReflection->is(TestCase::class)) {
+			return [];
+		}
+
 		$testMethods = [];
 		foreach ($classReflection->getNativeReflection()->getMethods() as $reflectionMethod) {
 			if (!$reflectionMethod->isPublic()) {

src/Type/PHPUnit/DataProviderReturnTypeIgnoreExtension.php

@@ -0,0 +1,56 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\PHPUnit;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Error;
+use PHPStan\Analyser\IgnoreErrorExtension;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\PHPUnit\DataProviderHelper;
+use PHPStan\Rules\PHPUnit\TestMethodsHelper;
+
+final class DataProviderReturnTypeIgnoreExtension implements IgnoreErrorExtension
+{
+
+	private TestMethodsHelper $testMethodsHelper;
+
+	private DataProviderHelper $dataProviderHelper;
+
+	public function __construct(
+		TestMethodsHelper $testMethodsHelper,
+		DataProviderHelper $dataProviderHelper
+	)
+	{
+		$this->testMethodsHelper = $testMethodsHelper;
+		$this->dataProviderHelper = $dataProviderHelper;
+	}
+
+	public function shouldIgnore(Error $error, Node $node, Scope $scope): bool
+	{
+		if ($error->getIdentifier() !== 'missingType.iterableValue') {
+			return false;
+		}
+
+		if (!$scope->isInClass()) {
+			return false;
+		}
+		$classReflection = $scope->getClassReflection();
+
+		$methodReflection = $scope->getFunction();
+		if ($methodReflection === null) {
+			return false;
+		}
+
+		$testMethods = $this->testMethodsHelper->getTestMethods($classReflection, $scope);
+		foreach ($testMethods as $testMethod) {
+			foreach ($this->dataProviderHelper->getDataProviderMethods($scope, $testMethod, $classReflection) as [, $providerMethodName]) {
+				if ($providerMethodName === $methodReflection->getName()) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+}

tests/Type/PHPUnit/DataProviderReturnTypeIgnoreExtensionTest.php

@@ -0,0 +1,38 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\PHPUnit;
+
+use PHPStan\Rules\Methods\MissingMethodReturnTypehintRule;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<MissingMethodReturnTypehintRule>
+ */
+class DataProviderReturnTypeIgnoreExtensionTest extends RuleTestCase {
+	protected function getRule(): Rule
+	{
+		/** @phpstan-ignore phpstanApi.classConstant */
+		$rule = self::getContainer()->getByType(MissingMethodReturnTypehintRule::class);
+
+		return $rule;
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/data-provider-iterable-value.php'], [
+			[
+				'Method DataProviderIterableValueTest\Foo::notADataProvider() return type has no value type specified in iterable type iterable.',
+				32,
+				'See: https://phpstan.org/blog/solving-phpstan-no-value-type-specified-in-iterable-type'
+			],
+		]);
+	}
+
+	static public function getAdditionalConfigFiles(): array
+	{
+		return [
+			__DIR__ . '/data/data-provider-iterable-value.neon'
+		];
+	}
+}

tests/Type/PHPUnit/data/data-provider-iterable-value.neon

@@ -0,0 +1,6 @@
+parameters:
+	phpunit:
+		checkDataProviderData: true
+
+includes:
+	- ../../../../extension.neon

tests/Type/PHPUnit/data/data-provider-iterable-value.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace DataProviderIterableValueTest;
+
+use PHPUnit\Framework\TestCase;
+
+class Foo extends TestCase {
+	/**
+	 * @dataProvider dataProvider
+	 * @dataProvider dataProvider2
+	 */
+	public function testFoo():void {
+
+	}
+
+	public function dataProvider(): iterable {
+		return [
+			[1, 2],
+			[3, 4],
+			[5, 6],
+		];
+	}
+
+	public function dataProvider2(): iterable {
+		$i = rand(0, 10);
+
+		return [
+			[$i, 2],
+		];
+	}
+
+	public function notADataProvider(): iterable {
+		return [
+			[1, 2],
+			[3, 4],
+			[5, 6],
+		];
+	}
+}