fix: apply dynamic parameter type extensions in FunctionCallParametersCheck

Author: calebdw

e2e/parameter-type-extension/phpstan-baseline.neon

@@ -1,5 +1,3 @@
-includes:
-	- phpstan-baseline.neon
 parameters:
 	level: 9
 	paths:

e2e/parameter-type-extension/phpstan.neon.dist

@@ -139,6 +139,7 @@ public function check(
 					),
 					$scope,
 					$attributeConstructor->getDeclaringClass()->isBuiltin(),
+					null,
 					new New_($attribute->name, $attribute->args, $nodeAttributes),
 					'attribute',
 					$attributeConstructor->acceptsNamedArguments(),

src/Rules/AttributesCheck.php

@@ -240,6 +240,7 @@ private function checkClassName(string $class, bool $isName, Node $node, Scope $
 			),
 			$scope,
 			$constructorReflection->getDeclaringClass()->isBuiltin(),
+			null,
 			$node,
 			'new',
 			$constructorReflection->acceptsNamedArguments(),

src/Rules/Classes/InstantiationRule.php

@@ -8,7 +8,10 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\AutowiredParameter;
 use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\DependencyInjection\Type\DynamicParameterTypeExtensionProvider;
 use PHPStan\Reflection\ExtendedParameterReflection;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\ParameterReflection;
 use PHPStan\Reflection\ParametersAcceptor;
 use PHPStan\Reflection\ResolvedFunctionVariant;
@@ -46,6 +49,7 @@ public function __construct(
 		private NullsafeCheck $nullsafeCheck,
 		private UnresolvableTypeHelper $unresolvableTypeHelper,
 		private PropertyReflectionFinder $propertyReflectionFinder,
+		private DynamicParameterTypeExtensionProvider $dynamicParameterTypeExtensionProvider,
 		#[AutowiredParameter(ref: '%checkFunctionArgumentTypes%')]
 		private bool $checkArgumentTypes,
 		#[AutowiredParameter]
@@ -66,6 +70,7 @@ public function check(
 		ParametersAcceptor $parametersAcceptor,
 		Scope $scope,
 		bool $isBuiltin,
+		MethodReflection|FunctionReflection|null $calleeReflection,
 		Node\Expr\FuncCall|Node\Expr\MethodCall|Node\Expr\StaticCall|Node\Expr\New_ $funcCall,
 		string $nodeType,
 		TrinaryLogic $acceptsNamedArguments,
@@ -349,6 +354,13 @@ public function check(
 			if ($this->checkArgumentTypes) {
 				$parameterType = TypeUtils::resolveLateResolvableTypes($parameter->getType());
 
+				if (! $funcCall instanceof Node\Expr\New_) {
+					$overriddenType = $this->getParameterTypeFromDynamicExtension($funcCall, $calleeReflection, $parameter, $scope);
+					if ($overriddenType !== null) {
+						$parameterType = $overriddenType;
+					}
+				}
+
 				if (
 					!$parameter->passedByReference()->createsNewVariable()
 					|| (!$isBuiltin && !$argumentValueType instanceof ErrorType)
@@ -688,4 +700,50 @@ private function describeParameter(ParameterReflection $parameter, int|string|nu
 		return implode(' ', $parts);
 	}
 
+	private function getParameterTypeFromDynamicExtension(
+		Node\Expr\FuncCall|Node\Expr\MethodCall|Node\Expr\StaticCall $funcCall,
+		MethodReflection|FunctionReflection|null $calleeReflection,
+		ParameterReflection $parameter,
+		Scope $scope,
+	): ?Type
+	{
+		if ($calleeReflection === null) {
+			return null;
+		}
+
+		if ($funcCall instanceof Node\Expr\FuncCall && $calleeReflection instanceof FunctionReflection) {
+			foreach ($this->dynamicParameterTypeExtensionProvider->getDynamicFunctionParameterTypeExtensions() as $extension) {
+				if (!$extension->isFunctionSupported($calleeReflection, $parameter)) {
+					continue;
+				}
+				$type = $extension->getTypeFromFunctionCall($calleeReflection, $funcCall, $parameter, $scope);
+				if ($type !== null) {
+					return $type;
+				}
+			}
+		} elseif ($funcCall instanceof Node\Expr\StaticCall && $calleeReflection instanceof MethodReflection) {
+			foreach ($this->dynamicParameterTypeExtensionProvider->getDynamicStaticMethodParameterTypeExtensions() as $extension) {
+				if (!$extension->isStaticMethodSupported($calleeReflection, $parameter)) {
+					continue;
+				}
+				$type = $extension->getTypeFromStaticMethodCall($calleeReflection, $funcCall, $parameter, $scope);
+				if ($type !== null) {
+					return $type;
+				}
+			}
+		} elseif ($funcCall instanceof Node\Expr\MethodCall && $calleeReflection instanceof MethodReflection) {
+			foreach ($this->dynamicParameterTypeExtensionProvider->getDynamicMethodParameterTypeExtensions() as $extension) {
+				if (!$extension->isMethodSupported($calleeReflection, $parameter)) {
+					continue;
+				}
+				$type = $extension->getTypeFromMethodCall($calleeReflection, $funcCall, $parameter, $scope);
+				if ($type !== null) {
+					return $type;
+				}
+			}
+		}
+
+		return null;
+	}
+
 }

src/Rules/FunctionCallParametersCheck.php

@@ -121,6 +121,7 @@ public function processNode(
 				$parametersAcceptor,
 				$scope,
 				false,
+				null,
 				$node,
 				'callable',
 				$acceptsNamedArguments,

src/Rules/Functions/CallCallablesRule.php

@@ -50,6 +50,7 @@ public function processNode(Node $node, Scope $scope): array
 			),
 			$scope,
 			$function->isBuiltin(),
+			$function,
 			$node,
 			'function',
 			$function->acceptsNamedArguments(),

src/Rules/Functions/CallToFunctionParametersRule.php

@@ -66,6 +66,7 @@ public function processNode(Node $node, Scope $scope): array
 			$parametersAcceptor,
 			$scope,
 			false,
+			null,
 			$funcCall,
 			'function',
 			$acceptsNamedArguments,

src/Rules/Functions/CallUserFuncRule.php

@@ -81,6 +81,7 @@ private function processSingleMethodCall(Scope $scope, MethodCall $node, string
 			),
 			$scope,
 			$declaringClass->isBuiltin(),
+			$methodReflection,
 			$node,
 			'method',
 			$methodReflection->acceptsNamedArguments(),

src/Rules/Methods/CallMethodsRule.php

@@ -90,6 +90,7 @@ private function processSingleMethodCall(Scope $scope, StaticCall $node, string
 			),
 			$scope,
 			$method->getDeclaringClass()->isBuiltin(),
+			$method,
 			$node,
 			'staticMethod',
 			$method->acceptsNamedArguments(),