Improve all* handling

Author: herndlm

src/Type/WebMozartAssert/AssertTypeSpecifyingExtension.php

@@ -23,9 +23,12 @@
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\Instanceof_;
 use PhpParser\Node\Expr\StaticCall;
+use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Name;
+use PhpParser\Node\Param;
 use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Scalar\String_;
+use PhpParser\Node\Stmt\Return_;
 use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\SpecifiedTypes;
 use PHPStan\Analyser\TypeSpecifier;
@@ -56,7 +59,6 @@
 use function count;
 use function key;
 use function lcfirst;
-use function reset;
 use function substr;
 
 class AssertTypeSpecifyingExtension implements StaticMethodTypeSpecifyingExtension, TypeSpecifierAwareExtension
@@ -133,36 +135,25 @@ public function specifyTypes(
 				$scope
 			);
 		}
+
+		if (substr($staticMethodReflection->getName(), 0, 3) === 'all') {
+			return $this->handleAll(
+				$staticMethodReflection->getName(),
+				$node,
+				$scope
+			);
+		}
+
 		$expression = self::createExpression($scope, $staticMethodReflection->getName(), $node->getArgs());
 		if ($expression === null) {
 			return new SpecifiedTypes([], []);
 		}
-		$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition(
+
+		return $this->typeSpecifier->specifyTypesInCondition(
 			$scope,
 			$expression,
 			TypeSpecifierContext::createTruthy()
 		);
-
-		if (substr($staticMethodReflection->getName(), 0, 3) === 'all') {
-			if (count($specifiedTypes->getSureTypes()) > 0) {
-				$sureTypes = $specifiedTypes->getSureTypes();
-				reset($sureTypes);
-				$exprString = key($sureTypes);
-				$sureType = $sureTypes[$exprString];
-				return $this->arrayOrIterable(
-					$scope,
-					$sureType[0],
-					static function () use ($sureType): Type {
-						return $sureType[1];
-					}
-				);
-			}
-			if (count($specifiedTypes->getSureNotTypes()) > 0) {
-				throw new ShouldNotHappenException();
-			}
-		}
-
-		return $specifiedTypes;
 	}
 
 	/**
@@ -758,6 +749,66 @@ static function (Type $type) use ($valueType): Type {
 		throw new ShouldNotHappenException();
 	}
 
+	private function handleAll(
+		string $methodName,
+		StaticCall $node,
+		Scope $scope
+	): SpecifiedTypes
+	{
+		$closureItemVariable = new Variable('item');
+		$closureArgs = $node->getArgs();
+		$closureArgs[0] = new Arg($closureItemVariable);
+
+		$expression = new BooleanAnd(
+			new FuncCall(new Name('is_iterable'), [$node->getArgs()[0]]),
+			new Identical(
+				$node->getArgs()[0]->value,
+				new FuncCall(
+					new Name('array_filter'),
+					[
+						new Arg($node->getArgs()[0]->value),
+						new Arg(
+							new Expr\Closure(
+								[
+									'static' => true,
+									'params' => [new Param($closureItemVariable)],
+									'stmts' => [
+										new Return_(self::createExpression($scope, $methodName, $closureArgs)),
+									],
+								]
+							)
+						),
+					]
+				)
+			)
+		);
+
+		$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition(
+			$scope,
+			$expression,
+			TypeSpecifierContext::createTruthy()
+		);
+
+		if (count($specifiedTypes->getSureTypes()) > 0) {
+			$sureTypes = $specifiedTypes->getSureTypes();
+			$exprString = key($sureTypes);
+			[$exprNode, $type] = $sureTypes[$exprString];
+
+			return $this->arrayOrIterable(
+				$scope,
+				$exprNode,
+				static function () use ($type): Type {
+					return $type->getIterableValueType();
+				}
+			);
+		}
+		if (count($specifiedTypes->getSureNotTypes()) > 0) {
+			throw new ShouldNotHappenException();
+		}
+
+		return $specifiedTypes;
+	}
+
 	private function arrayOrIterable(
 		Scope $scope,
 		Expr $expr,

tests/Type/WebMozartAssert/data/collection.php

@@ -8,28 +8,40 @@
 class CollectionTest
 {
 
-	public function allString(array $a): void
+	public function allString(array $a, $b): void
 	{
 		Assert::allString($a);
 		\PHPStan\Testing\assertType('array<string>', $a);
+
+		Assert::allString($b);
+		\PHPStan\Testing\assertType('iterable<string>', $b);
 	}
 
-	public function allStringNotEmpty(array $a): void
+	public function allStringNotEmpty(array $a, iterable $b, $c): void
 	{
 		Assert::allStringNotEmpty($a);
-		\PHPStan\Testing\assertType('array<string>', $a); // should be array<non-empty-string>
+		\PHPStan\Testing\assertType('array<non-empty-string>', $a);
+
+		Assert::allStringNotEmpty($b);
+		\PHPStan\Testing\assertType('iterable<non-empty-string>', $b);
+
+		Assert::allStringNotEmpty($c);
+		\PHPStan\Testing\assertType('iterable<non-empty-string>', $c);
 	}
 
-	public function allInteger(array $a, iterable $b, iterable $c): void
+	public function allInteger(array $a, iterable $b, $c): void
 	{
 		Assert::allInteger($a);
 		\PHPStan\Testing\assertType('array<int>', $a);
 
 		Assert::allInteger($b);
 		\PHPStan\Testing\assertType('iterable<int>', $b);
+
+		Assert::allInteger($c);
+		\PHPStan\Testing\assertType('iterable<int>', $c);
 	}
 
-	public function allInstanceOf(array $a, array $b, array $c): void
+	public function allInstanceOf(array $a, array $b, array $c, $d): void
 	{
 		Assert::allIsInstanceOf($a, stdClass::class);
 		\PHPStan\Testing\assertType('array<stdClass>', $a);
@@ -39,6 +51,9 @@ public function allInstanceOf(array $a, array $b, array $c): void
 
 		Assert::allIsInstanceOf($c, 17);
 		\PHPStan\Testing\assertType('array', $c);
+
+		Assert::allIsInstanceOf($d, new stdClass());
+		\PHPStan\Testing\assertType('iterable<stdClass>', $d);
 	}
 
 	/**
@@ -76,21 +91,24 @@ public function allNotSame(array $a): void
 		\PHPStan\Testing\assertType('array{1, -2|2, -3|3}', $a);
 	}
 
-	public function allSubclassOf(array $a, $b): void
+	public function allSubclassOf(array $a, iterable $b, $c): void
 	{
 		Assert::allSubclassOf($a, self::class);
 		\PHPStan\Testing\assertType('array<class-string<PHPStan\Type\WebMozartAssert\CollectionTest>|PHPStan\Type\WebMozartAssert\CollectionTest>', $a);
 
 		Assert::allSubclassOf($b, self::class);
 		\PHPStan\Testing\assertType('iterable<class-string<PHPStan\Type\WebMozartAssert\CollectionTest>|PHPStan\Type\WebMozartAssert\CollectionTest>', $b);
+
+		Assert::allSubclassOf($c, self::class);
+		\PHPStan\Testing\assertType('iterable<class-string<PHPStan\Type\WebMozartAssert\CollectionTest>|PHPStan\Type\WebMozartAssert\CollectionTest>', $c);
 	}
 
 	/**
 	 * @param array<array{id?: int}> $a
 	 * @param array<int, array<string, mixed>> $b
 	 *
 	 */
-	public function allKeyExists(array $a, array $b, array $c): void
+	public function allKeyExists(array $a, array $b, array $c, $d): void
 	{
 		Assert::allKeyExists($a, 'id');
 		\PHPStan\Testing\assertType('array<array{id: int}>', $a);