wip

Author: zonuexe

src/PhpDoc/PhpDocNodeResolver.php

@@ -46,6 +46,7 @@
 use function count;
 use function in_array;
 use function method_exists;
+use function preg_split;
 use function str_starts_with;
 use function substr;
 
@@ -416,6 +417,24 @@ public function resolveParamImmediatelyInvokedCallable(PhpDocNode $phpDocNode):
 		return $parameters;
 	}
 
+	/**
+	 * @return array<string, bool>
+	 */
+	public function resolveParamPureUnlessCallableIsImpure(PhpDocNode $phpDocNode): array
+	{
+		$parameters = [];
+		// TODO: implement phpstan/phpdoc-parser
+		foreach ($phpDocNode->getTagsByName('@pure-unless-callable-impure') as $tag) {
+			$value = preg_split('/\s/u', (string)$tag->value)[0] ?? null;
+			if ($value !== null && str_starts_with($value, '$')) {
+				$parameters[substr($value, 1)] = true;
+			}
+		}
+
+		return $parameters;
+	}
+
+
 	/**
 	 * @return array<string, ParamClosureThisTag>
 	 */

src/PhpDoc/ResolvedPhpDocBlock.php

@@ -95,6 +95,9 @@ final class ResolvedPhpDocBlock
 	/** @var array<string, bool>|false */
 	private array|false $paramsImmediatelyInvokedCallable = false;
 
+	/** @var array<string, bool>|false */
+	private array|false $paramsPureUnlessCallableIsImpure = false;
+
 	/** @var array<string, ParamClosureThisTag>|false */
 	private array|false $paramClosureThisTags = false;
 
@@ -212,6 +215,7 @@ public static function createEmpty(): self
 		$self->paramTags = [];
 		$self->paramOutTags = [];
 		$self->paramsImmediatelyInvokedCallable = [];
+		$self->paramsPureUnlessCallableIsImpure = [];
 		$self->paramClosureThisTags = [];
 		$self->returnTag = null;
 		$self->throwsTag = null;
@@ -276,6 +280,7 @@ public function merge(array $parents, array $parentPhpDocBlocks): self
 		$result->paramTags = self::mergeParamTags($this->getParamTags(), $parents, $parentPhpDocBlocks);
 		$result->paramOutTags = self::mergeParamOutTags($this->getParamOutTags(), $parents, $parentPhpDocBlocks);
 		$result->paramsImmediatelyInvokedCallable = self::mergeParamsImmediatelyInvokedCallable($this->getParamsImmediatelyInvokedCallable(), $parents, $parentPhpDocBlocks);
+		$result->paramsPureUnlessCallableIsImpure = self::mergeParamsPureUnlessCallableIsImpure($this->getParamsPureUnlessCallableIsImpure(), $parents, $parentPhpDocBlocks);
 		$result->paramClosureThisTags = self::mergeParamClosureThisTags($this->getParamClosureThisTags(), $parents, $parentPhpDocBlocks);
 		$result->returnTag = self::mergeReturnTags($this->getReturnTag(), $classReflection, $parents, $parentPhpDocBlocks);
 		$result->throwsTag = self::mergeThrowsTags($this->getThrowsTag(), $parents);
@@ -581,6 +586,18 @@ public function getParamsImmediatelyInvokedCallable(): array
 		return $this->paramsImmediatelyInvokedCallable;
 	}
 
+	/**
+	 * @return array<string, bool>
+	 */
+	public function getParamsPureUnlessCallableIsImpure(): array
+	{
+		if ($this->paramsPureUnlessCallableIsImpure === false) {
+			$this->paramsPureUnlessCallableIsImpure = $this->phpDocNodeResolver->resolveParamPureUnlessCallableIsImpure($this->phpDocNode);
+		}
+
+		return $this->paramsPureUnlessCallableIsImpure;
+	}
+
 	/**
 	 * @return array<string, ParamClosureThisTag>
 	 */
@@ -1161,6 +1178,40 @@ private static function mergeOneParentParamImmediatelyInvokedCallable(array $par
 		return $paramsImmediatelyInvokedCallable;
 	}
 
+	/**
+	 * @param array<string, bool> $paramsPureUnlessCallableIsImpure
+	 * @param array<int, self> $parents
+	 * @param array<int, PhpDocBlock> $parentPhpDocBlocks
+	 * @return array<string, bool>
+	 */
+	private static function mergeParamsPureUnlessCallableIsImpure(array $paramsPureUnlessCallableIsImpure, array $parents, array $parentPhpDocBlocks): array
+	{
+		foreach ($parents as $i => $parent) {
+			$paramsPureUnlessCallableIsImpure = self::mergeOneParentParamPureUnlessCallableIsImpure($paramsPureUnlessCallableIsImpure, $parent, $parentPhpDocBlocks[$i]);
+		}
+
+		return $paramsPureUnlessCallableIsImpure;
+	}
+
+	/**
+	 * @param array<string, bool> $paramsPureUnlessCallableIsImpure
+	 * @return array<string, bool>
+	 */
+	private static function mergeOneParentParamPureUnlessCallableIsImpure(array $paramsPureUnlessCallableIsImpure, self $parent, PhpDocBlock $phpDocBlock): array
+	{
+		$parentPureUnlessCallableIsImpure = $phpDocBlock->transformArrayKeysWithParameterNameMapping($parent->getParamsPureUnlessCallableIsImpure());
+
+		foreach ($parentPureUnlessCallableIsImpure as $name => $parentIsPureUnlessCallableIsImpure) {
+			if (array_key_exists($name, $paramsPureUnlessCallableIsImpure)) {
+				continue;
+			}
+
+			$paramsPureUnlessCallableIsImpure[$name] = $parentIsPureUnlessCallableIsImpure;
+		}
+
+		return $paramsPureUnlessCallableIsImpure;
+	}
+
 	/**
 	 * @param array<string, ParamClosureThisTag> $paramsClosureThisTags
 	 * @param array<int, self> $parents

tests/PHPStan/Analyser/nsrt/closure-passed-to-type.php

@@ -13,6 +13,7 @@ class Foo
 	 * @param array<T> $items
 	 * @param callable(T): U $cb
 	 * @return array<U>
+	 * @pure-unless-callable-impure $cb
 	 */
 	public function doFoo(array $items, callable $cb)
 	{

tests/PHPStan/Analyser/nsrt/param-pure-unless-callable-is-impure.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace ParamPureUnlessCallableIsImpure;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @template TValue
+ * @template TResult
+ * @param Closure(TValue): TResult $f
+ * @param iterable<TValue> $a
+ * @return array<TResult>
+ * @pure-unless-callable-is-impure $f
+ */
+function map(Closure $f, iterable $a): array
+{
+	$result = [];
+	foreach ($a as $i => $v) {
+		$retult[$i] = $f($v);
+	}
+
+	return $result;
+}
+
+map('printf', []);
+map('sprintf', []);
+
+assertType('array', map('printf', []));