Implement TypeSpecifierComparisonContext

src/Analyser/TypeSpecifier.php

@@ -38,6 +38,7 @@
 use PHPStan\Type\Accessory\NonEmptyArrayType;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\BooleanType;
+use PHPStan\Type\ComparisonAwareTypeSpecifyingExtension;
 use PHPStan\Type\ConditionalTypeForParameter;
 use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
@@ -2005,6 +2006,47 @@ private function getTypeSpecifyingExtensionsForType(array $extensions, string $c
 		return array_merge(...$extensionsForClass);
 	}
 
+	private function specifyWithComparisonAwareTypeSpecifyingExtensions(
+		Expr\BinaryOp $binaryOp,
+		Expr $callExpr,
+		Expr\CallLike $callLike,
+		Type $comparisonType,
+		Scope $scope,
+		TypeSpecifierContext $context,
+		?Expr $rootExpr,
+	): ?SpecifiedTypes
+	{
+		if ($callLike instanceof FuncCall && $callLike->name instanceof Name) {
+			if (!$this->reflectionProvider->hasFunction($callLike->name, $scope)) {
+				return null;
+			}
+			$functionReflection = $this->reflectionProvider->getFunction($callLike->name, $scope);
+
+			$comparisonContext = TypeSpecifierContext::createComparison(
+				new TypeSpecifierComparisonContext(
+					$binaryOp,
+					$callExpr,
+					$comparisonType,
+					$context,
+					$rootExpr,
+				),
+			);
+			foreach ($this->getFunctionTypeSpecifyingExtensions() as $extension) {
+				if (!$extension instanceof ComparisonAwareTypeSpecifyingExtension) {
+					continue;
+				}
+
+				if (!$extension->isFunctionSupported($functionReflection, $callLike, $comparisonContext)) {
+					continue;
+				}
+
+				return $extension->specifyTypes($functionReflection, $callLike, $scope, $comparisonContext);
+			}
+		}
+
+		return null;
+	}
+
 	public function resolveEqual(Expr\BinaryOp\Equal $expr, Scope $scope, TypeSpecifierContext $context, ?Expr $rootExpr): SpecifiedTypes
 	{
 		$expressions = $this->findTypeExpressionsFromBinaryOperation($scope, $expr);
@@ -2039,14 +2081,19 @@ public function resolveEqual(Expr\BinaryOp\Equal $expr, Scope $scope, TypeSpecif
 				return $this->specifyTypesInCondition($scope, new Expr\BinaryOp\Identical($expr->left, $expr->right), $context, $rootExpr);
 			}
 
-			if (
-				$context->true()
-				&& $exprNode instanceof FuncCall
-				&& $exprNode->name instanceof Name
-				&& $exprNode->name->toLowerString() === 'preg_match'
-				&& (new ConstantIntegerType(1))->isSuperTypeOf($constantType)->yes()
-			) {
-				return $this->specifyTypesInCondition($scope, new Expr\BinaryOp\Identical($expr->left, $expr->right), $context, $rootExpr);
+			if ($exprNode instanceof Expr\CallLike) {
+				$specifiedTypes = $this->specifyWithComparisonAwareTypeSpecifyingExtensions(
+					$expr,
+					$exprNode,
+					$exprNode,
+					$constantType,
+					$scope,
+					$context,
+					$rootExpr,
+				);
+				if ($specifiedTypes !== null) {
+					return $specifiedTypes;
+				}
 			}
 		}
 
@@ -2138,18 +2185,21 @@ public function resolveIdentical(Expr\BinaryOp\Identical $expr, Scope $scope, Ty
 		$rightType = $scope->getType($rightExpr);
 
 		if (
-			$context->true()
-			&& $unwrappedLeftExpr instanceof FuncCall
+			$unwrappedLeftExpr instanceof FuncCall
 			&& $unwrappedLeftExpr->name instanceof Name
-			&& $unwrappedLeftExpr->name->toLowerString() === 'preg_match'
-			&& (new ConstantIntegerType(1))->isSuperTypeOf($rightType)->yes()
 		) {
-			return $this->specifyTypesInCondition(
-				$scope,
+			$specifiedTypes = $this->specifyWithComparisonAwareTypeSpecifyingExtensions(
+				$expr,
 				$leftExpr,
+				$unwrappedLeftExpr,
+				$rightType,
+				$scope,
 				$context,
 				$rootExpr,
 			);
+			if ($specifiedTypes !== null) {
+				return $specifiedTypes;
+			}
 		}
 
 		if (

src/Analyser/TypeSpecifierComparisonContext.php

@@ -0,0 +1,48 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\BinaryOp;
+use PHPStan\Type\Type;
+
+/** @api */
+final class TypeSpecifierComparisonContext
+{
+
+	public function __construct(
+		private BinaryOp $binaryOp,
+		private Expr $callExpr,
+		private Type $comparisonType,
+		private TypeSpecifierContext $context,
+		private ?Expr $rootExpr,
+	)
+	{
+	}
+
+	public function getBinaryOp(): BinaryOp
+	{
+		return $this->binaryOp;
+	}
+
+	public function getCallExpr(): Expr
+	{
+		return $this->callExpr;
+	}
+
+	public function getComparisonType(): Type
+	{
+		return $this->comparisonType;
+	}
+
+	public function getTypeSpecifierContext(): TypeSpecifierContext
+	{
+		return $this->context;
+	}
+
+	public function getRootExpr(): ?Expr
+	{
+		return $this->rootExpr;
+	}
+
+}

src/Analyser/TypeSpecifierContext.php

@@ -17,19 +17,29 @@ class TypeSpecifierContext
 	public const CONTEXT_FALSE = 0b0100;
 	public const CONTEXT_FALSEY_BUT_NOT_FALSE = 0b1000;
 	public const CONTEXT_FALSEY = self::CONTEXT_FALSE | self::CONTEXT_FALSEY_BUT_NOT_FALSE;
-	public const CONTEXT_BITMASK = 0b1111;
+	public const CONTEXT_COMPARISON = 0b10000;
+	public const CONTEXT_BITMASK = 0b01111;
 
 	/** @var self[] */
 	private static array $registry;
 
-	private function __construct(private ?int $value)
+	private function __construct(
+		private ?int $value,
+		private ?TypeSpecifierComparisonContext $comparisonContext,
+	)
 	{
 	}
 
-	private static function create(?int $value): self
+	private static function create(?int $value, ?TypeSpecifierComparisonContext $comparisonContext = null): self
 	{
-		self::$registry[$value] ??= new self($value);
-		return self::$registry[$value];
+		if ($value !== self::CONTEXT_COMPARISON) {
+			self::$registry[$value] ??= new self($value, $comparisonContext);
+			return self::$registry[$value];
+		}
+
+		// each comparison context contains context dependent properties
+		// and therefore cannot be cached/re-used
+		return new self($value, $comparisonContext);
 	}
 
 	public static function createTrue(): self
@@ -52,6 +62,11 @@ public static function createFalsey(): self
 		return self::create(self::CONTEXT_FALSEY);
 	}
 
+	public static function createComparison(TypeSpecifierComparisonContext $comparisonContext): self
+	{
+		return self::create(self::CONTEXT_COMPARISON, $comparisonContext);
+	}
+
 	public static function createNull(): self
 	{
 		return self::create(null);
@@ -90,4 +105,9 @@ public function null(): bool
 		return $this->value === null;
 	}
 
+	public function comparison(): ?TypeSpecifierComparisonContext
+	{
+		return $this->comparisonContext;
+	}
+
 }

src/Type/ComparisonAwareTypeSpecifyingExtension.php

@@ -0,0 +1,18 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type;
+
+/**
+ * This is the marker interface *TypeSpecifyingExtension might implement to specify types for comparisons.
+ *
+ * Use it in your already registered type specifying extension.
+ *
+ * Learn more: https://phpstan.org/developing-extensions/type-specifying-extensions
+ *
+ * @api
+ *
+ */
+interface ComparisonAwareTypeSpecifyingExtension
+{
+
+}

src/Type/Php/PregMatchTypeSpecifyingExtension.php

@@ -2,6 +2,8 @@
 
 namespace PHPStan\Type\Php;
 
+use PhpParser\Node\Expr\BinaryOp\Equal;
+use PhpParser\Node\Expr\BinaryOp\Identical;
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\SpecifiedTypes;
@@ -10,11 +12,13 @@
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\TrinaryLogic;
+use PHPStan\Type\ComparisonAwareTypeSpecifyingExtension;
+use PHPStan\Type\Constant\ConstantIntegerType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
 use function in_array;
 use function strtolower;
 
-final class PregMatchTypeSpecifyingExtension implements FunctionTypeSpecifyingExtension, TypeSpecifierAwareExtension
+final class PregMatchTypeSpecifyingExtension implements FunctionTypeSpecifyingExtension, TypeSpecifierAwareExtension, ComparisonAwareTypeSpecifyingExtension
 {
 
 	private TypeSpecifier $typeSpecifier;
@@ -37,6 +41,25 @@ public function isFunctionSupported(FunctionReflection $functionReflection, Func
 
 	public function specifyTypes(FunctionReflection $functionReflection, FuncCall $node, Scope $scope, TypeSpecifierContext $context): SpecifiedTypes
 	{
+		$comparisonContext = $context->comparison();
+		if ($comparisonContext !== null) {
+			$binaryOp = $comparisonContext->getBinaryOp();
+			if (
+				($binaryOp instanceof Equal || $binaryOp instanceof Identical)
+				&& $comparisonContext->getTypeSpecifierContext()->true()
+				&& (new ConstantIntegerType(1))->isSuperTypeOf($comparisonContext->getComparisonType())->yes()
+			) {
+				return $this->typeSpecifier->specifyTypesInCondition(
+					$scope,
+					$comparisonContext->getCallExpr(),
+					$comparisonContext->getTypeSpecifierContext(),
+					$comparisonContext->getRootExpr(),
+				);
+			}
+
+			return new SpecifiedTypes();
+		}
+
 		$args = $node->getArgs();
 		$patternArg = $args[0] ?? null;
 		$matchesArg = $args[2] ?? null;