Clean up new isStatic/notStatic (#329)

shadowhand · web-flow · commit 68b79e9eb907 · 2025-12-03T07:30:34.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -16,7 +16,8 @@ Changelog
 - All assertion methods now return the checked value.
 - Added `notInArray` and `notOneOf`.
 - Added `isInitialized`, to check if a class property is initialized.
-- Added `notNegativeInteger` and `negativeInteger`
+- Added `negativeInteger` and `notNegativeInteger`
+- Added `isStatic` and `notStatic`
 
 ### Fixed
 
diff --git a/src/Assert.php b/src/Assert.php
@@ -2045,53 +2045,55 @@ public static function isMap(mixed $array, string $message = ''): array
     }
 
     /**
-     * @param Closure $closure
+     * @psalm-assert callable $callable
      *
-     * @psalm-pure
-     *
-     * @psalm-assert static Closure $closure
+     * @param Closure|callable $callable
      *
-     * @psalm-return static Closure
+     * @return Closure|callable-string
      *
      * @throws InvalidArgumentException
      */
-    public static function isStatic(mixed $closure, string $message = ''): Closure
+    public static function isStatic(mixed $callable, string $message = ''): Closure|string
     {
-        static::isCallable($closure, $message);
-        $reflection = new ReflectionFunction($closure);
+        static::isCallable($callable, $message);
+
+        $callable = static::callableToClosure($callable);
+
+        $reflection = new ReflectionFunction($callable);
 
         if (!$reflection->isStatic()) {
             static::reportInvalidArgument(
                 $message ?: 'Closure is not static.'
             );
         }
 
-        return $closure;
+        return $callable;
     }
 
     /**
-     * @param Closure $closure
-     *
-     * @psalm-pure
+     * @psalm-assert callable $callable
      *
-     * @psalm-assert Closure $closure
+     * @param Closure|callable $callable
      *
-     * @psalm-return Closure
+     * @return Closure|callable-string
      *
      * @throws InvalidArgumentException
      */
-    public static function notStatic(mixed $closure, string $message = ''): Closure
+    public static function notStatic(mixed $callable, string $message = ''): Closure|string
     {
-        static::isCallable($closure, $message);
-        $reflection = new ReflectionFunction($closure);
+        static::isCallable($callable, $message);
+
+        $callable = static::callableToClosure($callable);
+
+        $reflection = new ReflectionFunction($callable);
 
         if ($reflection->isStatic()) {
             static::reportInvalidArgument(
                 $message ?: 'Closure is not static.'
             );
         }
 
-        return $closure;
+        return $callable;
     }
 
     /**
@@ -2172,6 +2174,24 @@ public static function throws(mixed $expression, string $class = Throwable::clas
         ));
     }
 
+    /**
+     * @psalm-pure
+     *
+     * @return Closure|callable-string
+     */
+    protected static function callableToClosure(callable $callable): Closure|string
+    {
+        if (\is_string($callable) && \function_exists($callable)) {
+            return $callable;
+        }
+
+        if ($callable instanceof Closure) {
+            return $callable;
+        }
+
+        return $callable(...);
+    }
+
     /**
      * @psalm-pure
      */
diff --git a/src/Mixin.php b/src/Mixin.php
@@ -4956,127 +4956,115 @@ public static function allNullOrIsMap(mixed $array, string $message = ''): mixed
     }
 
     /**
-     * @param Closure|null $closure
+     * @psalm-assert callable|null $callable
      *
-     * @psalm-pure
-     *
-     * @psalm-assert static Closure|null $closure
+     * @param Closure|callable|null $callable
      *
-     * @return static Closure|null
+     * @return callable|null
      *
      * @throws InvalidArgumentException
      */
-    public static function nullOrIsStatic(mixed $closure, string $message = ''): mixed
+    public static function nullOrIsStatic(mixed $callable, string $message = ''): mixed
     {
-        null === $closure || static::isStatic($closure, $message);
+        null === $callable || static::isStatic($callable, $message);
 
-        return $closure;
+        return $callable;
     }
 
     /**
-     * @param iterable<Closure> $closure
-     *
-     * @psalm-pure
+     * @psalm-assert iterable<callable> $callable
      *
-     * @psalm-assert iterable<static Closure> $closure
+     * @param iterable<Closure|callable> $callable
      *
-     * @return iterable<static Closure>
+     * @return iterable<callable>
      *
      * @throws InvalidArgumentException
      */
-    public static function allIsStatic(mixed $closure, string $message = ''): mixed
+    public static function allIsStatic(mixed $callable, string $message = ''): mixed
     {
-        static::isIterable($closure);
+        static::isIterable($callable);
 
-        foreach ($closure as $entry) {
+        foreach ($callable as $entry) {
             static::isStatic($entry, $message);
         }
 
-        return $closure;
+        return $callable;
     }
 
     /**
-     * @param iterable<Closure|null> $closure
-     *
-     * @psalm-pure
+     * @psalm-assert iterable<callable|null> $callable
      *
-     * @psalm-assert iterable<static Closure|null> $closure
+     * @param iterable<Closure|callable|null> $callable
      *
-     * @return iterable<static Closure|null>
+     * @return iterable<callable|null>
      *
      * @throws InvalidArgumentException
      */
-    public static function allNullOrIsStatic(mixed $closure, string $message = ''): mixed
+    public static function allNullOrIsStatic(mixed $callable, string $message = ''): mixed
     {
-        static::isIterable($closure);
+        static::isIterable($callable);
 
-        foreach ($closure as $entry) {
+        foreach ($callable as $entry) {
             null === $entry || static::isStatic($entry, $message);
         }
 
-        return $closure;
+        return $callable;
     }
 
     /**
-     * @param Closure|null $closure
+     * @psalm-assert callable|null $callable
      *
-     * @psalm-pure
-     *
-     * @psalm-assert Closure|null $closure
+     * @param Closure|callable|null $callable
      *
-     * @return Closure|null
+     * @return callable|null
      *
      * @throws InvalidArgumentException
      */
-    public static function nullOrNotStatic(mixed $closure, string $message = ''): mixed
+    public static function nullOrNotStatic(mixed $callable, string $message = ''): mixed
     {
-        null === $closure || static::notStatic($closure, $message);
+        null === $callable || static::notStatic($callable, $message);
 
-        return $closure;
+        return $callable;
     }
 
     /**
-     * @param iterable<Closure> $closure
-     *
-     * @psalm-pure
+     * @psalm-assert iterable<callable> $callable
      *
-     * @psalm-assert iterable<Closure> $closure
+     * @param iterable<Closure|callable> $callable
      *
-     * @return iterable<Closure>
+     * @return iterable<callable>
      *
      * @throws InvalidArgumentException
      */
-    public static function allNotStatic(mixed $closure, string $message = ''): mixed
+    public static function allNotStatic(mixed $callable, string $message = ''): mixed
     {
-        static::isIterable($closure);
+        static::isIterable($callable);
 
-        foreach ($closure as $entry) {
+        foreach ($callable as $entry) {
             static::notStatic($entry, $message);
         }
 
-        return $closure;
+        return $callable;
     }
 
     /**
-     * @param iterable<Closure|null> $closure
-     *
-     * @psalm-pure
+     * @psalm-assert iterable<callable|null> $callable
      *
-     * @psalm-assert iterable<Closure|null> $closure
+     * @param iterable<Closure|callable|null> $callable
      *
-     * @return iterable<Closure|null>
+     * @return iterable<callable|null>
      *
      * @throws InvalidArgumentException
      */
-    public static function allNullOrNotStatic(mixed $closure, string $message = ''): mixed
+    public static function allNullOrNotStatic(mixed $callable, string $message = ''): mixed
     {
-        static::isIterable($closure);
+        static::isIterable($callable);
 
-        foreach ($closure as $entry) {
+        foreach ($callable as $entry) {
             null === $entry || static::notStatic($entry, $message);
         }
 
-        return $closure;
+        return $callable;
     }
 
     /**
diff --git a/tests/static-analysis/assert-isStatic.php b/tests/static-analysis/assert-isStatic.php
@@ -5,9 +5,10 @@
 use Closure;
 use Webmozart\Assert\Assert;
 
-function isStatic(Closure $closure): Closure
+/**
+ * @return Closure|callable-string
+ */
+function isStatic(mixed $closure): Closure|string
 {
-    Assert::isStatic($closure);
-
-    return $closure;
+    return Assert::isStatic($closure);
 }
diff --git a/tests/static-analysis/assert-notStatic.php b/tests/static-analysis/assert-notStatic.php
@@ -5,9 +5,10 @@
 use Closure;
 use Webmozart\Assert\Assert;
 
-function notStatic(Closure $closure): Closure
+/**
+ * @return Closure|callable-string
+ */
+function notStatic(mixed $closure): Closure|string
 {
-    Assert::notStatic($closure);
-
-    return $closure;
+    return Assert::notStatic($closure);
 }

Original file line number	Diff line number	Diff line change
`@@ -4956,127 +4956,115 @@ public static function allNullOrIsMap(mixed $array, string $message = ''): mixed`
`4956`	`4956`	`}`
`4957`	`4957`
`4958`	`4958`	`/**`
`4959`		`- * @param Closure\|null $closure`
	`4959`	`+ * @psalm-assert callable\|null $callable`
`4960`	`4960`	`*`
`4961`		`- * @psalm-pure`
`4962`		`- *`
`4963`		`- * @psalm-assert static Closure\|null $closure`
	`4961`	`+ * @param Closure\|callable\|null $callable`
`4964`	`4962`	`*`
`4965`		`- * @return static Closure\|null`
	`4963`	`+ * @return callable\|null`
`4966`	`4964`	`*`
`4967`	`4965`	`* @throws InvalidArgumentException`
`4968`	`4966`	`*/`
`4969`		`- public static function nullOrIsStatic(mixed $closure, string $message = ''): mixed`
	`4967`	`+ public static function nullOrIsStatic(mixed $callable, string $message = ''): mixed`
`4970`	`4968`	`{`
`4971`		`- null === $closure \|\| static::isStatic($closure, $message);`
	`4969`	`+ null === $callable \|\| static::isStatic($callable, $message);`
`4972`	`4970`
`4973`		`- return $closure;`
	`4971`	`+ return $callable;`
`4974`	`4972`	`}`
`4975`	`4973`
`4976`	`4974`	`/**`
`4977`		`- * @param iterable<Closure> $closure`
`4978`		`- *`
`4979`		`- * @psalm-pure`
	`4975`	`+ * @psalm-assert iterable<callable> $callable`
`4980`	`4976`	`*`
`4981`		`- * @psalm-assert iterable<static Closure> $closure`
	`4977`	`+ * @param iterable<Closure\|callable> $callable`
`4982`	`4978`	`*`
`4983`		`- * @return iterable<static Closure>`
	`4979`	`+ * @return iterable<callable>`
`4984`	`4980`	`*`
`4985`	`4981`	`* @throws InvalidArgumentException`
`4986`	`4982`	`*/`
`4987`		`- public static function allIsStatic(mixed $closure, string $message = ''): mixed`
	`4983`	`+ public static function allIsStatic(mixed $callable, string $message = ''): mixed`
`4988`	`4984`	`{`
`4989`		`- static::isIterable($closure);`
	`4985`	`+ static::isIterable($callable);`
`4990`	`4986`
`4991`		`- foreach ($closure as $entry) {`
	`4987`	`+ foreach ($callable as $entry) {`
`4992`	`4988`	`static::isStatic($entry, $message);`
`4993`	`4989`	`}`
`4994`	`4990`
`4995`		`- return $closure;`
	`4991`	`+ return $callable;`
`4996`	`4992`	`}`
`4997`	`4993`
`4998`	`4994`	`/**`
`4999`		`- * @param iterable<Closure\|null> $closure`
`5000`		`- *`
`5001`		`- * @psalm-pure`
	`4995`	`+ * @psalm-assert iterable<callable\|null> $callable`
`5002`	`4996`	`*`
`5003`		`- * @psalm-assert iterable<static Closure\|null> $closure`
	`4997`	`+ * @param iterable<Closure\|callable\|null> $callable`
`5004`	`4998`	`*`
`5005`		`- * @return iterable<static Closure\|null>`
	`4999`	`+ * @return iterable<callable\|null>`
`5006`	`5000`	`*`
`5007`	`5001`	`* @throws InvalidArgumentException`
`5008`	`5002`	`*/`
`5009`		`- public static function allNullOrIsStatic(mixed $closure, string $message = ''): mixed`
	`5003`	`+ public static function allNullOrIsStatic(mixed $callable, string $message = ''): mixed`
`5010`	`5004`	`{`
`5011`		`- static::isIterable($closure);`
	`5005`	`+ static::isIterable($callable);`
`5012`	`5006`
`5013`		`- foreach ($closure as $entry) {`
	`5007`	`+ foreach ($callable as $entry) {`
`5014`	`5008`	`null === $entry \|\| static::isStatic($entry, $message);`
`5015`	`5009`	`}`
`5016`	`5010`
`5017`		`- return $closure;`
	`5011`	`+ return $callable;`
`5018`	`5012`	`}`
`5019`	`5013`
`5020`	`5014`	`/**`
`5021`		`- * @param Closure\|null $closure`
	`5015`	`+ * @psalm-assert callable\|null $callable`
`5022`	`5016`	`*`
`5023`		`- * @psalm-pure`
`5024`		`- *`
`5025`		`- * @psalm-assert Closure\|null $closure`
	`5017`	`+ * @param Closure\|callable\|null $callable`
`5026`	`5018`	`*`
`5027`		`- * @return Closure\|null`
	`5019`	`+ * @return callable\|null`
`5028`	`5020`	`*`
`5029`	`5021`	`* @throws InvalidArgumentException`
`5030`	`5022`	`*/`
`5031`		`- public static function nullOrNotStatic(mixed $closure, string $message = ''): mixed`
	`5023`	`+ public static function nullOrNotStatic(mixed $callable, string $message = ''): mixed`
`5032`	`5024`	`{`
`5033`		`- null === $closure \|\| static::notStatic($closure, $message);`
	`5025`	`+ null === $callable \|\| static::notStatic($callable, $message);`
`5034`	`5026`
`5035`		`- return $closure;`
	`5027`	`+ return $callable;`
`5036`	`5028`	`}`
`5037`	`5029`
`5038`	`5030`	`/**`
`5039`		`- * @param iterable<Closure> $closure`
`5040`		`- *`
`5041`		`- * @psalm-pure`
	`5031`	`+ * @psalm-assert iterable<callable> $callable`
`5042`	`5032`	`*`
`5043`		`- * @psalm-assert iterable<Closure> $closure`
	`5033`	`+ * @param iterable<Closure\|callable> $callable`
`5044`	`5034`	`*`
`5045`		`- * @return iterable<Closure>`
	`5035`	`+ * @return iterable<callable>`
`5046`	`5036`	`*`
`5047`	`5037`	`* @throws InvalidArgumentException`
`5048`	`5038`	`*/`
`5049`		`- public static function allNotStatic(mixed $closure, string $message = ''): mixed`
	`5039`	`+ public static function allNotStatic(mixed $callable, string $message = ''): mixed`
`5050`	`5040`	`{`
`5051`		`- static::isIterable($closure);`
	`5041`	`+ static::isIterable($callable);`
`5052`	`5042`
`5053`		`- foreach ($closure as $entry) {`
	`5043`	`+ foreach ($callable as $entry) {`
`5054`	`5044`	`static::notStatic($entry, $message);`
`5055`	`5045`	`}`
`5056`	`5046`
`5057`		`- return $closure;`
	`5047`	`+ return $callable;`
`5058`	`5048`	`}`
`5059`	`5049`
`5060`	`5050`	`/**`
`5061`		`- * @param iterable<Closure\|null> $closure`
`5062`		`- *`
`5063`		`- * @psalm-pure`
	`5051`	`+ * @psalm-assert iterable<callable\|null> $callable`
`5064`	`5052`	`*`
`5065`		`- * @psalm-assert iterable<Closure\|null> $closure`
	`5053`	`+ * @param iterable<Closure\|callable\|null> $callable`
`5066`	`5054`	`*`
`5067`		`- * @return iterable<Closure\|null>`
	`5055`	`+ * @return iterable<callable\|null>`
`5068`	`5056`	`*`
`5069`	`5057`	`* @throws InvalidArgumentException`
`5070`	`5058`	`*/`
`5071`		`- public static function allNullOrNotStatic(mixed $closure, string $message = ''): mixed`
	`5059`	`+ public static function allNullOrNotStatic(mixed $callable, string $message = ''): mixed`
`5072`	`5060`	`{`
`5073`		`- static::isIterable($closure);`
	`5061`	`+ static::isIterable($callable);`
`5074`	`5062`
`5075`		`- foreach ($closure as $entry) {`
	`5063`	`+ foreach ($callable as $entry) {`
`5076`	`5064`	`null === $entry \|\| static::notStatic($entry, $message);`
`5077`	`5065`	`}`
`5078`	`5066`
`5079`		`- return $closure;`
	`5067`	`+ return $callable;`
`5080`	`5068`	`}`
`5081`	`5069`
`5082`	`5070`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,10 @@`
`5`	`5`	`use Closure;`
`6`	`6`	`use Webmozart\Assert\Assert;`
`7`	`7`
`8`		`-function isStatic(Closure $closure): Closure`
	`8`	`+/**`
	`9`	`+ * @return Closure\|callable-string`
	`10`	`+ */`
	`11`	`+function isStatic(mixed $closure): Closure\|string`
`9`	`12`	`{`
`10`		`- Assert::isStatic($closure);`
`11`		`-`
`12`		`- return $closure;`
	`13`	`+ return Assert::isStatic($closure);`
`13`	`14`	`}`