Improve DateInterval inference

Author: VincentLanglet

resources/functionMap_php83delta.php

@@ -21,6 +21,7 @@
  */
 return [
 	'new' => [
+		'DateInterval::createFromDateString' => ['static', 'modify'=>'string'],
 		'DateTime::modify' => ['static', 'modify'=>'string'],
 		'DateTimeImmutable::modify' => ['static', 'modify'=>'string'],
 		'str_decrement' => ['non-empty-string', 'string'=>'non-empty-string'],

src/Type/Php/DateIntervalCreateFromDateStringThrowTypeExtension.php

@@ -0,0 +1,61 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Php;
+
+use DateInterval;
+use PhpParser\Node\Expr\StaticCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Php\PhpVersion;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\DynamicStaticMethodThrowTypeExtension;
+use PHPStan\Type\NeverType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use function count;
+
+#[AutowiredService]
+final class DateIntervalCreateFromDateStringThrowTypeExtension implements DynamicStaticMethodThrowTypeExtension
+{
+
+	public function __construct(private PhpVersion $phpVersion)
+	{
+	}
+
+	public function isStaticMethodSupported(MethodReflection $methodReflection): bool
+	{
+		return $methodReflection->getName() === 'createFromDateString'
+			&& $methodReflection->getDeclaringClass()->getName() === DateInterval::class;
+	}
+
+	public function getThrowTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): ?Type
+	{
+		if (count($methodCall->getArgs()) === 0) {
+			return null;
+		}
+
+		if (!$this->phpVersion->hasDateTimeExceptions()) {
+			return null;
+		}
+
+		$valueType = $scope->getType($methodCall->getArgs()[0]->value);
+		$constantStrings = $valueType->getConstantStrings();
+
+		foreach ($constantStrings as $constantString) {
+			try {
+				DateInterval::createFromDateString($constantString->getValue());
+			} catch (\Exception) { // phpcs:ignore
+				return $methodReflection->getThrowType();
+			}
+
+			$valueType = TypeCombinator::remove($valueType, $constantString);
+		}
+
+		if (!$valueType instanceof NeverType) {
+			return $methodReflection->getThrowType();
+		}
+
+		return null;
+	}
+
+}

src/Type/Php/DateIntervalDynamicReturnTypeExtension.php

@@ -6,20 +6,23 @@
 use PhpParser\Node\Expr\StaticCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\DynamicStaticMethodReturnTypeExtension;
+use PHPStan\Type\NeverType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
 use Throwable;
-use function count;
-use function in_array;
 
 #[AutowiredService]
-final class DateIntervalDynamicReturnTypeExtension
-implements DynamicStaticMethodReturnTypeExtension
+final class DateIntervalDynamicReturnTypeExtension implements DynamicStaticMethodReturnTypeExtension
 {
 
+	public function __construct(private PhpVersion $phpVersion)
+	{
+	}
+
 	public function getClass(): string
 	{
 		return DateInterval::class;
@@ -40,31 +43,39 @@ public function getTypeFromStaticMethodCall(MethodReflection $methodReflection,
 
 		$strings = $scope->getType($arguments[0]->value)->getConstantStrings();
 
-		$possibleReturnTypes = [];
+		$hasFalse = false;
+		$hasDateInterval = false;
 		foreach ($strings as $string) {
 			try {
 				$result = @DateInterval::createFromDateString($string->getValue());
 			} catch (Throwable) {
-				$possibleReturnTypes[] = false;
+				$hasFalse = true;
 				continue;
 			}
-			$possibleReturnTypes[] = $result instanceof DateInterval ? DateInterval::class : false;
-		}
 
-		// the error case, when wrong types are passed
-		if (count($possibleReturnTypes) === 0) {
-			return null;
+			if ($result === false) {
+				$hasFalse = true;
+			} else {
+				$hasDateInterval = true;
+			}
 		}
 
-		if (in_array(false, $possibleReturnTypes, true) && in_array(DateInterval::class, $possibleReturnTypes, true)) {
+		if ($hasFalse) {
+			if (!$hasDateInterval) {
+				if ($this->phpVersion->hasDateTimeExceptions()) {
+					return new NeverType();
+				}
+
+				return new ConstantBooleanType(false);
+			}
+
 			return null;
 		}
-
-		if (in_array(false, $possibleReturnTypes, true)) {
-			return new ConstantBooleanType(false);
+		if ($hasDateInterval) {
+			return new ObjectType(DateInterval::class);
 		}
 
-		return new ObjectType(DateInterval::class);
+		return null;
 	}
 
 }

src/Type/Php/DateTimeModifyReturnTypeExtension.php

@@ -57,6 +57,7 @@ public function getTypeFromMethodCall(MethodReflection $methodReflection, Method
 			try {
 				$result = @(new DateTime())->modify($constantString->getValue());
 			} catch (Throwable) {
+				$hasFalse = false;
 				$valueType = TypeCombinator::remove($valueType, $constantString);
 				continue;
 			}
@@ -76,11 +77,16 @@ public function getTypeFromMethodCall(MethodReflection $methodReflection, Method
 
 		if ($hasFalse) {
 			if (!$hasDateTime) {
+				if ($this->phpVersion->hasDateTimeExceptions()) {
+					return new NeverType();
+				}
+
 				return new ConstantBooleanType(false);
 			}
 
 			return null;
-		} elseif ($hasDateTime) {
+		}
+		if ($hasDateTime) {
 			$callerType = $scope->getType($methodCall->var);
 
 			$dateTimeInterfaceType = new ObjectType(DateTimeInterface::class);
@@ -102,10 +108,6 @@ static function (Type $type, callable $traverse) use ($dateTimeInterfaceType): T
 			);
 		}
 
-		if ($this->phpVersion->hasDateTimeExceptions()) {
-			return new NeverType();
-		}
-
 		return null;
 	}
 

tests/PHPStan/Analyser/data/bug-14479-82.php

@@ -0,0 +1,22 @@
+<?php // lint < 8.3
+
+namespace Bug14479Php83;
+
+use function PHPStan\Testing\assertType;
+
+function test(string $input) {
+	assertType('DateInterval|false', \DateInterval::createFromDateString($input));
+}
+
+function testValid() {
+	assertType('DateInterval', \DateInterval::createFromDateString('P1D'));
+}
+
+function testInvalid() {
+	assertType('false', \DateInterval::createFromDateString('foo'));
+}
+
+/** @param 'P1D'|'foo' $input */
+function testUnion(string $input) {
+	assertType('DateInterval|false', \DateInterval::createFromDateString($input));
+}

tests/PHPStan/Analyser/data/bug-14479-83.php

@@ -0,0 +1,22 @@
+<?php // lint >= 8.3
+
+namespace Bug14479Php83;
+
+use function PHPStan\Testing\assertType;
+
+function test(string $input) {
+	assertType('DateInterval', \DateInterval::createFromDateString($input));
+}
+
+function testValid() {
+	assertType('DateInterval', \DateInterval::createFromDateString('P1D'));
+}
+
+function testInvalid() {
+	assertType('*NEVER*', \DateInterval::createFromDateString('foo'));
+}
+
+/** @param 'P1D'|'foo' $input */
+function testUnion(string $input) {
+	assertType('DateInterval', \DateInterval::createFromDateString($input));
+}

tests/PHPStan/Rules/Exceptions/CatchWithUnthrownExceptionRuleTest.php

@@ -748,6 +748,12 @@ public function testBug13806(): void
 		]);
 	}
 
+	#[RequiresPhp('>= 8.3.0')]
+	public function testBug14479(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-14479.php'], []);
+	}
+
 	public function testBug5952(): void
 	{
 		$this->analyse([__DIR__ . '/data/bug-5952.php'], [

tests/PHPStan/Rules/Exceptions/data/bug-14479.php

@@ -0,0 +1,33 @@
+<?php // lint >= 8.3
+
+namespace Bug14479;
+
+
+function test(string $input) {
+	try {
+		\DateInterval::createFromDateString($input);
+	} catch (\Exception $e) {
+	}
+}
+
+function testValid() {
+	try {
+		\DateInterval::createFromDateString('P1D');
+	} catch (\Exception $e) {
+	}
+}
+
+function testInvalid() {
+	try {
+		\DateInterval::createFromDateString('foo');
+	} catch (\Exception $e) {
+	}
+}
+
+/** @param 'P1D'|'foo' $input */
+function testUnion(string $input) {
+	try {
+		\DateInterval::createFromDateString($input);
+	} catch (\Exception $e) {
+	}
+}