added ArrowFunctionVoidIgnoreExtension

Author: dg

CLAUDE.md

@@ -44,6 +44,10 @@ Extensions for specific Nette packages use dedicated namespaces: `Nette\PHPStan\
 
 `ExpectArrayReturnTypeExtension` (`DynamicStaticMethodReturnTypeExtension`) narrows the return type of `Expect::array()` from `Structure|Type` to `Structure` or `Type`. It inspects the argument: no argument, null, empty array, or non-Schema values → `Type`; all values implementing `Schema` → `Structure`; mixed/unknown → fallback to declared union. Config: `extension-schema.neon`.
 
+### ArrowFunctionVoidIgnoreExtension
+
+`ArrowFunctionVoidIgnoreExtension` (`IgnoreErrorExtension`) suppresses `argument.type` when an arrow function (which always returns a value) is passed to a parameter typed as `Closure(): void`. The list of affected functions/methods is configurable via a flat NEON list — plain names for functions (`testException`), `Class::method` notation for methods (`Tester\Assert::exception`). Config: `extension-tester.neon`.
+
 ### ClosureTypeCheckIgnoreExtension
 
 `ClosureTypeCheckIgnoreExtension` (`IgnoreErrorExtension`) suppresses `expr.resultUnused` for the runtime type validation pattern `(function(Type ...$p) {})(...$args)`. Config: `extension-php.neon`.

extension-tester.neon

@@ -0,0 +1,12 @@
+services:
+	-
+		class: Nette\PHPStan\Php\ArrowFunctionVoidIgnoreExtension([
+			test
+			testException
+			testNoError
+			Tester\Assert::exception
+			Tester\Assert::throws
+			Tester\Assert::error
+			Tester\Assert::noError
+		])
+		tags: [phpstan.ignoreErrorExtension]

extension.neon

@@ -16,3 +16,4 @@ parameters:
 includes:
 	- extension-php.neon
 	- extension-schema.neon
+	- extension-tester.neon

readme.md

@@ -55,6 +55,18 @@ $cwd = getcwd();
 
  <!---->
 
+### Arrow Function Void Ignore
+
+Suppresses `argument.type` when an arrow function is passed to a parameter typed as `Closure(): void`. Arrow functions always return a value, so PHPStan reports a type mismatch even though the return value is simply discarded. This extension ignores the error for [configured functions](extension-tester.neon) like `test`, `testException`, `testNoError`, `Assert::exception`, `Assert::throws`, `Assert::error`, and `Assert::noError`.
+
+```php
+// Without extension: argument.type error
+// With extension: no error
+testException('listOf() & error', fn() => Expect::listOf(['a' => Expect::string()]), TypeError::class);
+```
+
+ <!---->
+
 ### Other
 
 - Narrows the return type of `Expect::array()` from `Structure|Type` to `Structure` or `Type` based on the argument

src/Php/ArrowFunctionVoidIgnoreExtension.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nette\PHPStan\Php;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Error;
+use PHPStan\Analyser\IgnoreErrorExtension;
+use PHPStan\Analyser\Scope;
+use function str_contains, substr_count;
+
+
+/**
+ * Suppresses 'argument.type' when an arrow function (which always returns a value) is passed
+ * to a parameter typed as Closure(): void. The list of affected functions/methods is configurable.
+ */
+class ArrowFunctionVoidIgnoreExtension implements IgnoreErrorExtension
+{
+	/** @var list<string> */
+	private array $functions = [];
+
+	/** @var list<string> */
+	private array $methods = [];
+
+
+	/** @param list<string> $items  plain names for functions, Class::method for methods */
+	public function __construct(array $items)
+	{
+		foreach ($items as $item) {
+			if (str_contains($item, '::')) {
+				$this->methods[] = $item;
+			} else {
+				$this->functions[] = $item;
+			}
+		}
+	}
+
+
+	public function shouldIgnore(Error $error, Node $node, Scope $scope): bool
+	{
+		if ($error->getIdentifier() !== 'argument.type') {
+			return false;
+		}
+
+		$message = $error->getMessage();
+
+		if (!str_contains($message, 'Closure(): void')) {
+			return false;
+		}
+
+		if (substr_count($message, 'Closure(') < 2) {
+			return false;
+		}
+
+		foreach ($this->functions as $function) {
+			if (str_contains($message, "function $function(")) {
+				return true;
+			}
+		}
+
+		foreach ($this->methods as $method) {
+			if (str_contains($message, "$method(")) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+}

tests/Php/ArrowFunctionVoidIgnoreTest.phpt

@@ -0,0 +1,7 @@
+<?php declare(strict_types=1);
+
+require __DIR__ . '/../bootstrap.php';
+
+use Nette\PHPStan\Tester\TypeAssert;
+
+TypeAssert::assertNoErrors(__DIR__ . '/../data/arrow-function-void.php', [__DIR__ . '/../data/arrow-function-void.neon']);

tests/data/arrow-function-void.neon

@@ -0,0 +1,5 @@
+includes:
+	- ../../extension.neon
+
+parameters:
+	checkMissingCallableSignature: false

tests/data/arrow-function-void.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tester {
+	class Assert
+	{
+		/** @param \Closure(): void $function */
+		public static function exception(\Closure $function, string $class): void
+		{
+		}
+
+
+		/** @param \Closure(): void $function */
+		public static function noError(\Closure $function): void
+		{
+		}
+	}
+}
+
+namespace {
+	/** @param Closure(): void $function */
+	function testException(string $description, Closure $function, string $class): void
+	{
+	}
+
+
+	/** @param Closure(): void $function */
+	function testNoError(string $description, Closure $function): void
+	{
+	}
+
+
+	testException('test', fn() => strlen('hello'), TypeError::class);
+	testNoError('test', fn() => strlen('hello'));
+
+	Tester\Assert::exception(fn() => strlen('hello'), TypeError::class);
+	Tester\Assert::noError(fn() => strlen('hello'));
+}