Callable prototypes

conf/config.neon

@@ -36,6 +36,7 @@ parameters:
 	checkGenericClassInNonGenericObjectType: false
 	checkInternalClassCaseSensitivity: false
 	checkMissingIterableValueType: false
+	checkMissingCallablePrototype: false
 	checkMissingVarTagTypehint: false
 	checkArgumentsPassedByReference: false
 	checkMaybeUndefinedVariables: false
@@ -186,6 +187,7 @@ parametersSchema:
 	checkGenericClassInNonGenericObjectType: bool()
 	checkInternalClassCaseSensitivity: bool()
 	checkMissingIterableValueType: bool()
+	checkMissingCallablePrototype: bool()
 	checkMissingVarTagTypehint: bool()
 	checkArgumentsPassedByReference: bool()
 	checkMaybeUndefinedVariables: bool()
@@ -727,6 +729,7 @@ services:
 		arguments:
 			checkMissingIterableValueType: %checkMissingIterableValueType%
 			checkGenericClassInNonGenericObjectType: %checkGenericClassInNonGenericObjectType%
+			checkMissingCallablePrototype: %checkMissingCallablePrototype%
 
 	-
 		class: PHPStan\Rules\NullsafeCheck

src/Command/AnalyserRunner.php

@@ -36,8 +36,8 @@ public function __construct(
 	/**
 	 * @param string[] $files
 	 * @param string[] $allAnalysedFiles
-	 * @param \Closure|null $preFileCallback
-	 * @param \Closure|null $postFileCallback
+	 * @param (\Closure(string $file): void)|null $preFileCallback
+	 * @param (\Closure(int): void)|null $postFileCallback
 	 * @param bool $debug
 	 * @param bool $allowParallel
 	 * @param string|null $projectConfigFile

src/Rules/Functions/MissingFunctionParameterTypehintRule.php

@@ -92,6 +92,15 @@ private function checkFunctionParameter(FunctionReflection $functionReflection,
 			))->tip(MissingTypehintCheck::TURN_OFF_NON_GENERIC_CHECK_TIP)->build();
 		}
 
+		foreach ($this->missingTypehintCheck->getCallablesWithMissingPrototype($parameterType) as $callableType) {
+			$messages[] = RuleErrorBuilder::message(sprintf(
+				'Function %s() has parameter $%s with no prototype specified for callable type %s.',
+				$functionReflection->getName(),
+				$parameterReflection->getName(),
+				$callableType->describe(VerbosityLevel::typeOnly())
+			))->build();
+		}
+
 		return $messages;
 	}
 

src/Rules/Functions/MissingFunctionReturnTypehintRule.php

@@ -65,6 +65,14 @@ public function processNode(Node $node, Scope $scope): array
 			))->tip(MissingTypehintCheck::TURN_OFF_NON_GENERIC_CHECK_TIP)->build();
 		}
 
+		foreach ($this->missingTypehintCheck->getCallablesWithMissingPrototype($returnType) as $callableType) {
+			$messages[] = RuleErrorBuilder::message(sprintf(
+				'Function %s() return type has no prototype specified for callable type %s.',
+				$functionReflection->getName(),
+				$callableType->describe(VerbosityLevel::typeOnly())
+			))->build();
+		}
+
 		return $messages;
 	}
 

src/Rules/Methods/MissingMethodParameterTypehintRule.php

@@ -92,6 +92,16 @@ private function checkMethodParameter(MethodReflection $methodReflection, Parame
 			))->tip(MissingTypehintCheck::TURN_OFF_NON_GENERIC_CHECK_TIP)->build();
 		}
 
+		foreach ($this->missingTypehintCheck->getCallablesWithMissingPrototype($parameterType) as $callableType) {
+			$messages[] = RuleErrorBuilder::message(sprintf(
+				'Method %s::%s() has parameter $%s with no prototype specified for callable type %s.',
+				$methodReflection->getDeclaringClass()->getDisplayName(),
+				$methodReflection->getName(),
+				$parameterReflection->getName(),
+				$callableType->describe(VerbosityLevel::typeOnly())
+			))->build();
+		}
+
 		return $messages;
 	}
 

src/Rules/Methods/MissingMethodReturnTypehintRule.php

@@ -70,6 +70,15 @@ public function processNode(Node $node, Scope $scope): array
 			))->tip(MissingTypehintCheck::TURN_OFF_NON_GENERIC_CHECK_TIP)->build();
 		}
 
+		foreach ($this->missingTypehintCheck->getCallablesWithMissingPrototype($returnType) as $callableType) {
+			$messages[] = RuleErrorBuilder::message(sprintf(
+				'Method %s::%s() return type has no prototype specified for callable type %s.',
+				$methodReflection->getDeclaringClass()->getDisplayName(),
+				$methodReflection->getName(),
+				$callableType->describe(VerbosityLevel::typeOnly())
+			))->build();
+		}
+
 		return $messages;
 	}
 

src/Rules/MissingTypehintCheck.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Rules;
 
 use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Type\CallableType;
 use PHPStan\Type\Generic\GenericObjectType;
 use PHPStan\Type\Generic\TemplateType;
 use PHPStan\Type\Generic\TemplateTypeHelper;
@@ -32,15 +33,20 @@ class MissingTypehintCheck
 
 	private bool $checkGenericClassInNonGenericObjectType;
 
+	/** @var bool */
+	private $checkMissingCallablePrototype;
+
 	public function __construct(
 		ReflectionProvider $reflectionProvider,
 		bool $checkMissingIterableValueType,
-		bool $checkGenericClassInNonGenericObjectType
+		bool $checkGenericClassInNonGenericObjectType,
+		bool $checkMissingCallablePrototype
 	)
 	{
 		$this->reflectionProvider = $reflectionProvider;
 		$this->checkMissingIterableValueType = $checkMissingIterableValueType;
 		$this->checkGenericClassInNonGenericObjectType = $checkGenericClassInNonGenericObjectType;
+		$this->checkMissingCallablePrototype = $checkMissingCallablePrototype;
 	}
 
 	/**
@@ -133,4 +139,27 @@ public function getNonGenericObjectTypesWithGenericClass(Type $type): array
 		return $objectTypes;
 	}
 
+	/**
+	 * @param \PHPStan\Type\Type $type
+	 * @return \PHPStan\Type\Type[]
+	 */
+	public function getCallablesWithMissingPrototype(Type $type): array
+	{
+		if (!$this->checkMissingCallablePrototype) {
+			return [];
+		}
+
+		$result = [];
+		TypeTraverser::map($type, static function (Type $type, callable $traverse) use (&$result): Type {
+			if (
+				($type instanceof CallableType && $type->isCommonCallable()) ||
+				($type instanceof ObjectType && $type->getClassName() === \Closure::class)) {
+				$result[] = $type;
+			}
+			return $traverse($type);
+		});
+
+		return $result;
+	}
+
 }

src/Rules/Properties/MissingPropertyTypehintRule.php

@@ -67,6 +67,15 @@ public function processNode(Node $node, Scope $scope): array
 			))->tip(MissingTypehintCheck::TURN_OFF_NON_GENERIC_CHECK_TIP)->build();
 		}
 
+		foreach ($this->missingTypehintCheck->getCallablesWithMissingPrototype($propertyType) as $callableType) {
+			$messages[] = RuleErrorBuilder::message(sprintf(
+				'Property %s::$%s type has no prototype specified for callable type %s.',
+				$propertyReflection->getDeclaringClass()->getDisplayName(),
+				$node->getName(),
+				$callableType->describe(VerbosityLevel::typeOnly())
+			))->build();
+		}
+
 		return $messages;
 	}
 

src/Type/CallableType.php

@@ -298,6 +298,11 @@ public function isNumericString(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isCommonCallable(): bool
+	{
+		return $this->isCommonCallable;
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 * @return Type

tests/PHPStan/Analyser/data/Foo-callable.php

@@ -7,7 +7,7 @@
 class Foo
 {
 	/**
-	 * @param Foo|callable $xxx
+	 * @param Foo|(callable(): mixed) $xxx
 	 */
 	public function abc($xxx): void
 	{

tests/PHPStan/Levels/data/acceptTypes-6.json

@@ -54,6 +54,11 @@
         "line": 148,
         "ignorable": true
     },
+    {
+        "message": "Method Levels\\AcceptTypes\\Foo::expectCallable() has parameter $callable with no prototype specified for callable type callable.",
+        "line": 148,
+        "ignorable": true
+    },
     {
         "message": "Method Levels\\AcceptTypes\\Foo::iterableCountable() has no return typehint specified.",
         "line": 160,
@@ -144,9 +149,24 @@
         "line": 570,
         "ignorable": true
     },
+    {
+        "message": "Method Levels\\AcceptTypes\\ArrayShapes::doFoo() has parameter $callables with no prototype specified for callable type callable.",
+        "line": 570,
+        "ignorable": true
+    },
+    {
+        "message": "Method Levels\\AcceptTypes\\ArrayShapes::doFoo() has parameter $iterable with no prototype specified for callable type callable.",
+        "line": 570,
+        "ignorable": true
+    },
     {
         "message": "Method Levels\\AcceptTypes\\ArrayShapes::doBar() has no return typehint specified.",
         "line": 603,
         "ignorable": true
+    },
+    {
+        "message": "Method Levels\\AcceptTypes\\ArrayShapes::doBar() has parameter $one with no prototype specified for callable type callable.",
+        "line": 603,
+        "ignorable": true
     }
 ]

tests/PHPStan/Levels/data/casts.php

@@ -7,7 +7,7 @@ class Foo
 
 	/**
 	 * @param mixed[] $array
-	 * @param mixed[]|callable $arrayOrCallable
+	 * @param mixed[]|(callable(): mixed) $arrayOrCallable
 	 * @param mixed[]|float|int $arrayOrFloatOrInt
 	 */
 	public function doFoo(

tests/PHPStan/Levels/data/echo_.php

@@ -8,7 +8,7 @@ class Foo
 {
 	/**
 	 * @param mixed[] $array
-	 * @param mixed[]|callable $arrayOrCallable
+	 * @param mixed[]|(callable(): mixed) $arrayOrCallable
 	 * @param mixed[]|float|int $arrayOrFloatOrInt
 	 * @param mixed[]|string $arrayOrString
 	 */

tests/PHPStan/Levels/data/encapsedString.php

@@ -7,7 +7,7 @@ class Foo
 
 	/**
 	 * @param mixed[] $array
-	 * @param mixed[]|callable $arrayOrCallable
+	 * @param mixed[]|(callable(): mixed) $arrayOrCallable
 	 * @param mixed[]|float|int $arrayOrFloatOrInt
 	 * @param mixed[]|string $arrayOrString
 	 */

tests/PHPStan/Levels/data/print_.php

@@ -8,7 +8,7 @@ class Foo
 {
 	/**
 	 * @param mixed[] $array
-	 * @param mixed[]|callable $arrayOrCallable
+	 * @param mixed[]|(callable(): mixed) $arrayOrCallable
 	 * @param mixed[]|float|int $arrayOrFloatOrInt
 	 * @param mixed[]|string $arrayOrString
 	 */

tests/PHPStan/Rules/Classes/MixinRuleTest.php

@@ -24,7 +24,7 @@ protected function getRule(): Rule
 			$reflectionProvider,
 			new ClassCaseSensitivityCheck($reflectionProvider),
 			new GenericObjectTypeCheck(),
-			new MissingTypehintCheck($reflectionProvider, true, true),
+			new MissingTypehintCheck($reflectionProvider, true, true, true),
 			true
 		);
 	}

tests/PHPStan/Rules/Functions/MissingFunctionParameterTypehintRuleTest.php

@@ -13,7 +13,7 @@ class MissingFunctionParameterTypehintRuleTest extends \PHPStan\Testing\RuleTest
 	protected function getRule(): \PHPStan\Rules\Rule
 	{
 		$broker = $this->createReflectionProvider();
-		return new MissingFunctionParameterTypehintRule(new MissingTypehintCheck($broker, true, true));
+		return new MissingFunctionParameterTypehintRule(new MissingTypehintCheck($broker, true, true, true));
 	}
 
 	public function testRule(): void

tests/PHPStan/Rules/Functions/MissingFunctionReturnTypehintRuleTest.php

@@ -13,7 +13,7 @@ class MissingFunctionReturnTypehintRuleTest extends \PHPStan\Testing\RuleTestCas
 	protected function getRule(): \PHPStan\Rules\Rule
 	{
 		$broker = $this->createReflectionProvider();
-		return new MissingFunctionReturnTypehintRule(new MissingTypehintCheck($broker, true, true));
+		return new MissingFunctionReturnTypehintRule(new MissingTypehintCheck($broker, true, true, true));
 	}
 
 	public function testRule(): void
@@ -48,6 +48,18 @@ public function testRule(): void
 				105,
 				'You can turn this off by setting <fg=cyan>checkGenericClassInNonGenericObjectType: false</> in your <fg=cyan>%configurationFile%</>.',
 			],
+			[
+				'Function MissingFunctionReturnTypehint\closureWithNoPrototype() return type has no prototype specified for callable type Closure.',
+				113,
+			],
+			[
+				'Function MissingFunctionReturnTypehint\callableWithNoPrototype() return type has no prototype specified for callable type callable.',
+				127,
+			],
+			[
+				'Function MissingFunctionReturnTypehint\callableNestedNoPrototype() return type has no prototype specified for callable type callable.',
+				141,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Functions/data/missing-function-return-typehint.php

@@ -106,4 +106,46 @@ function genericGenericMissingTemplateArgs(): GenericClass
 	{
 
 	}
+
+	/**
+	 * @return \Closure
+	 */
+	function closureWithNoPrototype() : \Closure{
+
+	}
+
+	/**
+	 * @return \Closure(int) : void
+	 */
+	function closureWithPrototype() : \Closure{
+
+	}
+
+	/**
+	 * @return callable
+	 */
+	function callableWithNoPrototype() : callable{
+
+	}
+
+	/**
+	 * @return callable(int) : void
+	 */
+	function callableWithPrototype() : callable{
+
+	}
+
+	/**
+	 * @return callable(callable) : void
+	 */
+	function callableNestedNoPrototype() : callable{
+
+	}
+
+	/**
+	 * @return callable(callable(int) : void) : void
+	 */
+	function callableNestedWithPrototype() : callable{
+
+	}
 }

tests/PHPStan/Rules/Methods/MissingMethodParameterTypehintRuleTest.php

@@ -13,7 +13,7 @@ class MissingMethodParameterTypehintRuleTest extends \PHPStan\Testing\RuleTestCa
 	protected function getRule(): \PHPStan\Rules\Rule
 	{
 		$broker = $this->createReflectionProvider();
-		return new MissingMethodParameterTypehintRule(new MissingTypehintCheck($broker, true, true));
+		return new MissingMethodParameterTypehintRule(new MissingTypehintCheck($broker, true, true, true));
 	}
 
 	public function testRule(): void

tests/PHPStan/Rules/Methods/MissingMethodReturnTypehintRuleTest.php

@@ -13,7 +13,7 @@ class MissingMethodReturnTypehintRuleTest extends \PHPStan\Testing\RuleTestCase
 	protected function getRule(): \PHPStan\Rules\Rule
 	{
 		$broker = $this->createReflectionProvider();
-		return new MissingMethodReturnTypehintRule(new MissingTypehintCheck($broker, true, true));
+		return new MissingMethodReturnTypehintRule(new MissingTypehintCheck($broker, true, true, true));
 	}
 
 	public function testRule(): void

tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php

@@ -23,7 +23,7 @@ protected function getRule(): Rule
 			$broker,
 			new ClassCaseSensitivityCheck($broker),
 			new GenericObjectTypeCheck(),
-			new MissingTypehintCheck($broker, true, true),
+			new MissingTypehintCheck($broker, true, true, true),
 			true,
 			true
 		);

tests/PHPStan/Rules/Properties/MissingPropertyTypehintRuleTest.php

@@ -13,7 +13,7 @@ class MissingPropertyTypehintRuleTest extends \PHPStan\Testing\RuleTestCase
 	protected function getRule(): \PHPStan\Rules\Rule
 	{
 		$broker = $this->createReflectionProvider();
-		return new MissingPropertyTypehintRule(new MissingTypehintCheck($broker, true, true));
+		return new MissingPropertyTypehintRule(new MissingTypehintCheck($broker, true, true, true));
 	}
 
 	public function testRule(): void