Make isSatisfiedBy() less annoying, scan tests with PHPStan

Author: dktapps

phpstan.neon.dist

@@ -3,3 +3,4 @@ parameters:
 	treatPhpDocTypesAsCertain: false
 	paths:
 		- src
+		- tests

src/Prototype.php

@@ -46,7 +46,7 @@ private static function convertReflectionType(?\ReflectionType $type) : ?BaseTyp
 		return $type === null ? null : self::convertReflectionTypeInner($type);
 	}
 
-	public static function createFromCallable(\Closure $callable) : Prototype{
+	public static function fromClosure(\Closure $callable) : Prototype{
 		$reflection = new \ReflectionFunction($callable);
 
 		$returnType = new ReturnInfo(self::convertReflectionType($reflection->getReturnType()), $reflection->returnsReference());
@@ -77,20 +77,18 @@ public function __construct(ReturnInfo $returnType, ParameterInfo ...$parameters
 		}
 	}
 
-	public function isSatisfiedBy(\Closure $callable) : bool{
-		$other = self::createFromCallable($callable);
-
-		if(!$this->returnInfo->isSatisfiedBy($other->returnInfo)){
+	public function isSatisfiedBy(Prototype $callable) : bool{
+		if(!$this->returnInfo->isSatisfiedBy($callable->returnInfo)){
 			return false;
 		}
 
-		if($other->requiredParameterCount > $this->requiredParameterCount){
+		if($callable->requiredParameterCount > $this->requiredParameterCount){
 			return false;
 		}
 
 		$last = null;
 
-		foreach($other->parameters as $position => $parameter){
+		foreach($callable->parameters as $position => $parameter){
 			// Parameters that exist in the prototype must always be satisfied directly
 			if(isset($this->parameters[$position])){
 				if(!$this->parameters[$position]->isSatisfiedBy($parameter)){

tests/Base/Fixtures/ClassImplementingInvoke.php

@@ -4,5 +4,7 @@
 
 class ClassImplementingInvoke
 {
-    public function __invoke() {}
+    public function __invoke() : mixed{
+		return null;
+	}
 }

tests/Base/Fixtures/ClassImplementingIteratorAggregate.php

@@ -2,4 +2,7 @@
 
 namespace DaveRandom\CallbackValidator\Test\Base\Fixtures;
 
+/**
+ * @phpstan-implements \IteratorAggregate<mixed, mixed>
+ */
 abstract class ClassImplementingIteratorAggregate implements \IteratorAggregate {}

tests/Base/PrototypeTest.php

@@ -16,20 +16,20 @@ public static function returnCovarianceProvider() : \Generator{
 		yield [function() : void{}, function() : void{}, true, "same type"];
 		yield [function(){}, function() : void{}, true, "unspecified type allows not returning anything (the same as void)"];
 
-		yield [function() : int{ return 0; }, function(){}, false, "given function might return nothing, which is not allowed by an int type"];
-		yield [function() : mixed{ return 0; }, function(){}, false, "given function might return nothing, which is not allowed by a mixed type"];
+		yield [function() : int{ die(); }, function(){}, false, "given function might return nothing, which is not allowed by an int type"];
+		yield [function() : mixed{ die(); }, function(){}, false, "given function might return nothing, which is not allowed by a mixed type"];
 
-		yield [function() : int|string{ return 0; }, function() : int{ return 0; }, true, "given function returns a type which is covariant with required"];
-		yield [function() : int{ return 0; }, function() : int|string{ return 0; }, false, "given function returns a type which is not covariant with required"];
-		yield [function() : float{ return 0; }, function() : int{ return 0; }, true, "int is covariant with float"];
+		yield [function() : int|string{ die(); }, function() : int{ die(); }, true, "given function returns a type which is covariant with required"];
+		yield [function() : int{ die(); }, function() : int|string{ die(); }, false, "given function returns a type which is not covariant with required"];
+		yield [function() : float{ die(); }, function() : int{ die(); }, true, "int is covariant with float"];
 
-		yield [function() : Interface1{}, function() : Interface1&Interface2{}, true, "covariant intersection type"];
-		yield [function() : Interface1&Interface2{}, function() : Interface1{}, false, "given type not covariant with required intersection"];
+		yield [function() : Interface1{ die(); }, function() : Interface1&Interface2{ die(); }, true, "covariant intersection type"];
+		yield [function() : Interface1&Interface2{ die(); }, function() : Interface1{ die(); }, false, "given type not covariant with required intersection"];
 
-		yield [function() : mixed{}, function() : int{}, true, "int is covariant with mixed"];
-		yield [function() : mixed{}, function() : int|string{}, true, "int|string is covariant with mixed"];
-		yield [function() : mixed{}, function() : Interface1&Interface2{}, true, "intersection is covariant with mixed"];
-		yield [function() : mixed{}, function() : void{}, false, "void is not covariant with mixed"];
+		yield [function() : mixed{ die(); }, function() : int{ die(); }, true, "int is covariant with mixed"];
+		yield [function() : mixed{ die(); }, function() : int|string{ die(); }, true, "int|string is covariant with mixed"];
+		yield [function() : mixed{ die(); }, function() : Interface1&Interface2{ die(); }, true, "intersection is covariant with mixed"];
+		yield [function() : mixed{ die(); }, function() : void{}, false, "void is not covariant with mixed"];
 	}
 
 	public static function paramContravarianceProvider() : \Generator{
@@ -81,10 +81,11 @@ public static function paramContravarianceProvider() : \Generator{
 	#[DataProvider('returnCovarianceProvider')]
 	#[DataProvider('paramContravarianceProvider')]
 	public function testCompatibility(\Closure $required, \Closure $given, bool $matches, string $reason) : void{
-		$required = Prototype::createFromCallable($required);
+		$required = Prototype::fromClosure($required);
+		$given = Prototype::fromClosure($given);
 
 		$serializedRequire = (string) $required;
-		$serializedGiven = (string) Prototype::createFromCallable($given);
+		$serializedGiven = (string) $given;
 		self::assertSame($required->isSatisfiedBy($given), $matches, $reason . " ($serializedRequire, $serializedGiven)");
 	}
 }

tests/Php82/PrototypeTest.php

@@ -12,8 +12,8 @@ class PrototypeTest extends TestCase{
 
 	public static function returnCovarianceProvider() : \Generator{
 		//DNF types - PHP 8.2+ only
-		yield [function() : (Interface1&Interface2)|string{}, function() : Interface1{}, false, "given type not covariant with any part of required union"];
-		yield [function() : (Interface1&Interface2)|string{}, function() : Interface1&Interface2{}, true, "given type covariant with at least 1 part of required union"];
+		yield [function() : (Interface1&Interface2)|string{ die(); }, function() : Interface1{ die(); }, false, "given type not covariant with any part of required union"];
+		yield [function() : (Interface1&Interface2)|string{ die(); }, function() : Interface1&Interface2{ die(); }, true, "given type covariant with at least 1 part of required union"];
 	}
 
 	public static function paramContravarianceProvider() : \Generator{
@@ -27,10 +27,11 @@ public static function paramContravarianceProvider() : \Generator{
 	#[DataProvider('returnCovarianceProvider')]
 	#[DataProvider('paramContravarianceProvider')]
 	public function testCompatibility(\Closure $required, \Closure $given, bool $matches, string $reason) : void{
-		$required = Prototype::createFromCallable($required);
+		$required = Prototype::fromClosure($required);
+		$given = Prototype::fromClosure($given);
 
 		$serializedRequire = (string) $required;
-		$serializedGiven = (string) Prototype::createFromCallable($given);
+		$serializedGiven = (string) $given;
 		self::assertSame($required->isSatisfiedBy($given), $matches, $reason . " ($serializedRequire, $serializedGiven)");
 	}
 }