Extend JsonThrowOnErrorDynamicReturnTypeExtension to detect knonw type from contssant string value

Author: TomasVotruba

src/Type/Php/JsonThrowOnErrorDynamicReturnTypeExtension.php

@@ -2,18 +2,41 @@
 
 namespace PHPStan\Type\Php;
 
+<<<<<<< HEAD
+=======
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\BinaryOp\BitwiseOr;
+use PhpParser\Node\Expr\ConstFetch;
+>>>>>>> Extend JsonThrowOnErrorDynamicReturnTypeExtension to detect knonw type from contssant string value
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Name\FullyQualified;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Reflection\ReflectionProvider;
+<<<<<<< HEAD
 use PHPStan\Type\BitwiseFlagHelper;
 use PHPStan\Type\Constant\ConstantBooleanType;
+=======
+use PHPStan\Type\ArrayType;
+use PHPStan\Type\BooleanType;
+use PHPStan\Type\Constant\ConstantBooleanType;
+use PHPStan\Type\Constant\ConstantIntegerType;
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\ConstantTypeHelper;
+>>>>>>> Extend JsonThrowOnErrorDynamicReturnTypeExtension to detect knonw type from contssant string value
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
+use PHPStan\Type\FloatType;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use function in_array;
+use PHPStan\Type\UnionType;
+use stdClass;
+use function json_decode;
 
 class JsonThrowOnErrorDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
 {
@@ -35,14 +58,11 @@ public function isFunctionSupported(
 		FunctionReflection $functionReflection,
 	): bool
 	{
-		return $this->reflectionProvider->hasConstant(new FullyQualified('JSON_THROW_ON_ERROR'), null) && in_array(
-			$functionReflection->getName(),
-			[
-				'json_encode',
-				'json_decode',
-			],
-			true,
-		);
+		if ($functionReflection->getName() === 'json_decode') {
+			return true;
+		}
+
+		return $this->reflectionProvider->hasConstant(new FullyQualified('JSON_THROW_ON_ERROR'), null) && $functionReflection->getName() === 'json_encode';
 	}
 
 	public function getTypeFromFunctionCall(
@@ -51,8 +71,19 @@ public function getTypeFromFunctionCall(
 		Scope $scope,
 	): Type
 	{
+		// update type based on JSON_THROW_ON_ERROR
 		$argumentPosition = $this->argumentPositions[$functionReflection->getName()];
 		$defaultReturnType = ParametersAcceptorSelector::selectSingle($functionReflection->getVariants())->getReturnType();
+
+		// narrow type for json_decode()
+		if ($functionReflection->getName() === 'json_decode') {
+			$jsonDecodeNarrowedType = $this->narrowTypeForJsonDecode($functionCall, $scope);
+			// improve type
+			if (! $jsonDecodeNarrowedType instanceof MixedType) {
+				$defaultReturnType = $jsonDecodeNarrowedType;
+			}
+		}
+
 		if (!isset($functionCall->getArgs()[$argumentPosition])) {
 			return $defaultReturnType;
 		}
@@ -65,4 +96,73 @@ public function getTypeFromFunctionCall(
 		return $defaultReturnType;
 	}
 
+	private function narrowTypeForJsonDecode(FuncCall $funcCall, Scope $scope): Type
+	{
+		$args = $funcCall->getArgs();
+		$isForceArray = $this->isForceArray($funcCall);
+
+		$firstArgValue = $args[0]->value;
+		$firstValueType = $scope->getType($firstArgValue);
+
+		if ($firstValueType instanceof ConstantStringType) {
+			$resolvedType = $this->resolveConstantStringType($firstValueType, $isForceArray);
+		} else {
+			$resolvedType = new MixedType();
+		}
+
+		// prefer specific type
+		if (! $resolvedType instanceof MixedType) {
+			return $resolvedType;
+		}
+
+		// fallback type
+		if ($isForceArray) {
+			return new UnionType([
+				new ArrayType(new MixedType(), new MixedType()),
+				new StringType(),
+				new FloatType(),
+				new IntegerType(),
+				new BooleanType(),
+			]);
+		}
+
+		// scalar types with stdClass
+		return new UnionType([
+			new ObjectType(stdClass::class),
+			new StringType(),
+			new FloatType(),
+			new IntegerType(),
+			new BooleanType(),
+		]);
+	}
+
+	/**
+	 * Is "json_decode(..., true)"?
+	 * @param Arg[] $args
+	 */
+	private function isForceArray(FuncCall $funcCall): bool
+	{
+		$args = $funcCall->getArgs();
+
+		if (!isset($args[1])) {
+			return false;
+		}
+
+		$secondArgValue = $args[1]->value;
+		if ($secondArgValue instanceof ConstFetch) {
+			if ($secondArgValue->name->toLowerString() === 'true') {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	private function resolveConstantStringType(ConstantStringType $constantStringType, bool $isForceArray): Type
+	{
+		$decodedValue = json_decode($constantStringType->getValue(), $isForceArray);
+
+		return ConstantTypeHelper::getTypeFromValue($decodedValue);
+	}
+
 }