Improve all* handling

Author: herndlm

src/Type/WebMozartAssert/AssertTypeSpecifyingExtension.php

@@ -786,7 +786,7 @@ private function handleAllNot(
 	): SpecifiedTypes
 	{
 		if ($methodName === 'allNotNull') {
-			return $this->arrayOrIterable(
+			return $this->allArrayOrIterable(
 				$scope,
 				$node->getArgs()[0]->value,
 				static function (Type $type): Type {
@@ -806,7 +806,7 @@ static function (Type $type): Type {
 				return new SpecifiedTypes([], []);
 			}
 
-			return $this->arrayOrIterable(
+			return $this->allArrayOrIterable(
 				$scope,
 				$node->getArgs()[0]->value,
 				static function (Type $type) use ($objectType): Type {
@@ -817,7 +817,7 @@ static function (Type $type) use ($objectType): Type {
 
 		if ($methodName === 'allNotSame') {
 			$valueType = $scope->getType($node->getArgs()[1]->value);
-			return $this->arrayOrIterable(
+			return $this->allArrayOrIterable(
 				$scope,
 				$node->getArgs()[0]->value,
 				static function (Type $type) use ($valueType): Type {
@@ -864,7 +864,7 @@ private function handleAll(
 				$type = $typeModifier($type);
 			}
 
-			return $this->arrayOrIterable(
+			return $this->allArrayOrIterable(
 				$scope,
 				$node->getArgs()[0]->value,
 				static function () use ($type): Type {
@@ -877,7 +877,7 @@ static function () use ($type): Type {
 		return $specifiedTypes;
 	}
 
-	private function arrayOrIterable(
+	private function allArrayOrIterable(
 		Scope $scope,
 		Expr $expr,
 		Closure $typeCallback,
@@ -892,18 +892,30 @@ private function arrayOrIterable(
 				if ($arrayType instanceof ConstantArrayType) {
 					$builder = ConstantArrayTypeBuilder::createEmpty();
 					foreach ($arrayType->getKeyTypes() as $i => $keyType) {
-						$valueType = $arrayType->getValueTypes()[$i];
-						$builder->setOffsetValueType($keyType, $typeCallback($valueType), $arrayType->isOptionalKey($i));
+						$valueType = $typeCallback($arrayType->getValueTypes()[$i]);
+						if ($valueType instanceof NeverType) {
+							continue 2;
+						}
+						$builder->setOffsetValueType($keyType, $valueType, $arrayType->isOptionalKey($i));
 					}
 					$newArrayTypes[] = $builder->getArray();
 				} else {
-					$newArrayTypes[] = new ArrayType($arrayType->getKeyType(), $typeCallback($arrayType->getItemType()));
+					$itemType = $typeCallback($arrayType->getItemType());
+					if ($itemType instanceof NeverType) {
+						continue;
+					}
+					$newArrayTypes[] = new ArrayType($arrayType->getKeyType(), $itemType);
 				}
 			}
 
 			$specifiedType = TypeCombinator::union(...$newArrayTypes);
 		} elseif ((new IterableType(new MixedType(), new MixedType()))->isSuperTypeOf($currentType)->yes()) {
-			$specifiedType = new IterableType($currentType->getIterableKeyType(), $typeCallback($currentType->getIterableValueType()));
+			$itemType = $typeCallback($currentType->getIterableValueType());
+			if ($itemType instanceof NeverType) {
+				$specifiedType = $itemType;
+			} else {
+				$specifiedType = new IterableType($currentType->getIterableKeyType(), $itemType);
+			}
 		} else {
 			return new SpecifiedTypes([], []);
 		}

tests/Type/WebMozartAssert/data/collection.php

@@ -98,12 +98,20 @@ public function allNotInstanceOf(array $a, array $b, array $c): void
 		assertType('array<PHPStan\Type\WebMozartAssert\CollectionFoo>', $c);
 	}
 
-	public function allNotNull(array $arr): void
+	public function allNotNull(array $arr, iterable $iter): void
 	{
 		/** @var (int|null)[] $arr */
 		Assert::allNotNull($arr);
 		assertType('array<int>', $arr);
 
+		/** @var null[] $arr */
+		Assert::allNotNull($arr);
+		assertType('*NEVER*', $arr);
+
+		/** @var iterable<null> $iter */
+		Assert::allNotNull($iter);
+		assertType('*NEVER*', $iter);
+
 		/** @var array{baz: float|null}|array{foo?: string|null, bar: int|null} $arr */
 		Assert::allNotNull($arr);
 		assertType('array{baz: float}|array{foo?: string, bar: int}', $arr);
@@ -117,7 +125,11 @@ public function allNotSame(array $arr): void
 
 		/** @var array{-1, -2, -3}|array{1, 2, 3} $arr */
 		Assert::allNotSame($arr, -1);
-		assertType('array{*NEVER*, -2, -3}|array{1, 2, 3}', $arr);
+		assertType('array{1, 2, 3}', $arr);
+
+		/** @var array{-1, -2, -3} $arr */
+		Assert::allNotSame($arr, -1);
+		assertType('*NEVER*', $arr);
 	}
 
 	public function allSubclassOf(array $a, iterable $b, $c): void