Allow yield with nullable/union return types by checking each union member for an iterable, non-array part

src/Rules/Generators/GeneratorReturnTypeHelper.php

@@ -0,0 +1,37 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Generators;
+
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypeUtils;
+
+final class GeneratorReturnTypeHelper
+{
+
+	/**
+	 * Extracts the part of a generator function's declared return type that can
+	 * actually hold the yielded Generator. Nullable or union return types like
+	 * ?Generator or Iterator|float are valid in PHP, but their non-iterable parts
+	 * (null, float, ...) would otherwise poison getIterableKeyType()/getIterableValueType()
+	 * with ErrorType and silently disable yield key/value type checks.
+	 */
+	public static function getGeneratorType(Type $returnType): Type
+	{
+		$iterableTypes = [];
+		foreach (TypeUtils::flattenTypes($returnType) as $innerType) {
+			if ($innerType->isIterable()->no() || $innerType->isArray()->yes()) {
+				continue;
+			}
+
+			$iterableTypes[] = $innerType;
+		}
+
+		if ($iterableTypes === []) {
+			return $returnType;
+		}
+
+		return TypeCombinator::union(...$iterableTypes);
+	}
+
+}

src/Rules/Generators/YieldFromTypeRule.php

@@ -81,6 +81,8 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
+		$returnType = GeneratorReturnTypeHelper::getGeneratorType($returnType);
+
 		$messages = [];
 		$acceptsKey = $this->ruleLevelHelper->accepts($returnType->getIterableKeyType(), $exprType->getIterableKeyType(), $scope->isDeclareStrictTypes());
 		if (!$acceptsKey->result) {
@@ -115,7 +117,7 @@ public function processNode(Node $node, Scope $scope): array
 			return $messages;
 		}
 
-		$currentReturnType = $scopeFunction->getReturnType();
+		$currentReturnType = GeneratorReturnTypeHelper::getGeneratorType($scopeFunction->getReturnType());
 		$exprSendType = $exprType->getTemplateType(Generator::class, 'TSend');
 		$thisSendType = $currentReturnType->getTemplateType(Generator::class, 'TSend');
 		if ($exprSendType instanceof ErrorType || $thisSendType instanceof ErrorType) {

src/Rules/Generators/YieldInGeneratorRule.php

@@ -11,6 +11,7 @@
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\NeverType;
+use PHPStan\Type\TypeUtils;
 use function sprintf;
 
 /**
@@ -60,9 +61,16 @@ public function processNode(Node $node, Scope $scope): array
 		if ($returnType instanceof NeverType && $returnType->isExplicit()) {
 			$isSuperType = TrinaryLogic::createNo();
 		} else {
-			$isSuperType = $returnType->isIterable()->and(TrinaryLogic::createFromBoolean(
-				!$returnType->isArray()->yes(),
-			));
+			// A function containing yield always returns a Generator at runtime, so the
+			// declared return type is valid as long as at least one of its parts can hold
+			// a Generator (iterable but not array). This mirrors PHP's own rule, which
+			// permits nullable and union return types like ?Generator or Iterator|float.
+			$isSuperType = TrinaryLogic::createNo();
+			foreach (TypeUtils::flattenTypes($returnType) as $innerType) {
+				$isSuperType = $isSuperType->or($innerType->isIterable()->and(TrinaryLogic::createFromBoolean(
+					!$innerType->isArray()->yes(),
+				)));
+			}
 		}
 		if ($isSuperType->yes()) {
 			return [];

src/Rules/Generators/YieldTypeRule.php

@@ -48,6 +48,8 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
+		$returnType = GeneratorReturnTypeHelper::getGeneratorType($returnType);
+
 		if ($node->key === null) {
 			$keyType = new IntegerType();
 		} else {

tests/PHPStan/Rules/Generators/YieldFromTypeRuleTest.php

@@ -65,4 +65,14 @@ public function testBug11517(): void
 		$this->analyse([__DIR__ . '/data/bug-11517.php'], []);
 	}
 
+	public function testBug6190(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-6190-from.php'], [
+			[
+				'Generator expects value type Bug6190From\Food, int given.',
+				23,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Generators/YieldInGeneratorRuleTest.php

@@ -27,14 +27,6 @@ public function testRule(): void
 				'Yield can be used only with these return types: Generator, Iterator, Traversable, iterable.',
 				14,
 			],
-			[
-				'Yield can be used only with these return types: Generator, Iterator, Traversable, iterable.',
-				31,
-			],
-			[
-				'Yield can be used only with these return types: Generator, Iterator, Traversable, iterable.',
-				32,
-			],
 			[
 				'Yield can be used only with these return types: Generator, Iterator, Traversable, iterable.',
 				37,
@@ -59,6 +51,14 @@ public function testRule(): void
 				'Yield can be used only with these return types: Generator, Iterator, Traversable, iterable.',
 				88,
 			],
+			[
+				'Yield can be used only with these return types: Generator, Iterator, Traversable, iterable.',
+				132,
+			],
+			[
+				'Yield can be used only with these return types: Generator, Iterator, Traversable, iterable.',
+				133,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Generators/YieldTypeRuleTest.php

@@ -87,4 +87,22 @@ public function testYieldOversizedSelfRejection(): void
 		$this->analyse([__DIR__ . '/data/bug-yield-oversized-self-rejection.php'], []);
 	}
 
+	public function testBug6190(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-6190.php'], [
+			[
+				'Generator expects value type Bug6190\Food, int given.',
+				21,
+			],
+			[
+				'Generator expects value type Bug6190\Food, string given.',
+				30,
+			],
+			[
+				'Generator expects key type int, string given.',
+				38,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Generators/data/bug-6190-from.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Bug6190From;
+
+class Food
+{
+
+	public static function bone(): self
+	{
+		return new self();
+	}
+
+}
+
+/**
+ * @param \Generator<int, Food> $good
+ * @param \Generator<int, int> $bad
+ * @return \Generator<int, Food>|null
+ */
+function nullableGenerator($good, $bad)
+{
+	yield from $good;
+	yield from $bad;
+}

tests/PHPStan/Rules/Generators/data/bug-6190.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Bug6190;
+
+class Food
+{
+
+	public static function bone(): self
+	{
+		return new self();
+	}
+
+}
+
+/**
+ * @return \Generator<int, Food>|null
+ */
+function nullableGenerator()
+{
+	yield Food::bone();
+	yield 5;
+}
+
+/**
+ * @return \Iterator<int, Food>|float
+ */
+function unionGenerator()
+{
+	yield Food::bone();
+	yield 'foo';
+}
+
+/**
+ * @return \Generator<int, Food>|null
+ */
+function nullableGeneratorWrongKey()
+{
+	yield 'key' => Food::bone();
+}

tests/PHPStan/Rules/Generators/data/yield-in-generator.php

@@ -87,3 +87,48 @@ function doNever()
 	yield 1;
 	yield from doFoo();
 }
+
+/**
+ * @return \Generator|null
+ */
+function doNullableGenerator()
+{
+	yield 1;
+	yield from doFoo();
+}
+
+/**
+ * @return \Iterator|float
+ */
+function doIteratorFloat()
+{
+	yield 1;
+	yield from doFoo();
+}
+
+/**
+ * @return \Traversable|null
+ */
+function doNullableTraversable()
+{
+	yield 1;
+	yield from doFoo();
+}
+
+/**
+ * @return iterable|null
+ */
+function doNullableIterable()
+{
+	yield 1;
+	yield from doFoo();
+}
+
+/**
+ * @return string|null
+ */
+function doNullableString()
+{
+	yield 1;
+	yield from doFoo();
+}