Call operator type specifying extensions for bitwise and arithmetic operators

src/Reflection/InitializerExprTypeResolver.php

@@ -986,6 +986,12 @@ public function getBitwiseAndType(Expr $left, Expr $right, callable $getTypeCall
 		$leftType = $getTypeCallback($left);
 		$rightType = $getTypeCallback($right);
 
+		$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
+			->callOperatorTypeSpecifyingExtensions(new BinaryOp\BitwiseAnd($left, $right), $leftType, $rightType);
+		if ($specifiedTypes !== null) {
+			return $specifiedTypes;
+		}
+
 		return $this->getBitwiseAndTypeFromTypes($leftType, $rightType);
 	}
 
@@ -1044,6 +1050,12 @@ public function getBitwiseOrType(Expr $left, Expr $right, callable $getTypeCallb
 		$leftType = $getTypeCallback($left);
 		$rightType = $getTypeCallback($right);
 
+		$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
+			->callOperatorTypeSpecifyingExtensions(new BinaryOp\BitwiseOr($left, $right), $leftType, $rightType);
+		if ($specifiedTypes !== null) {
+			return $specifiedTypes;
+		}
+
 		return $this->getBitwiseOrTypeFromTypes($leftType, $rightType);
 	}
 
@@ -1092,6 +1104,12 @@ public function getBitwiseXorType(Expr $left, Expr $right, callable $getTypeCall
 		$leftType = $getTypeCallback($left);
 		$rightType = $getTypeCallback($right);
 
+		$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
+			->callOperatorTypeSpecifyingExtensions(new BinaryOp\BitwiseXor($left, $right), $leftType, $rightType);
+		if ($specifiedTypes !== null) {
+			return $specifiedTypes;
+		}
+
 		return $this->getBitwiseXorTypeFromTypes($leftType, $rightType);
 	}
 
@@ -1756,6 +1774,12 @@ public function getShiftLeftType(Expr $left, Expr $right, callable $getTypeCallb
 		$leftType = $getTypeCallback($left);
 		$rightType = $getTypeCallback($right);
 
+		$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
+			->callOperatorTypeSpecifyingExtensions(new BinaryOp\ShiftLeft($left, $right), $leftType, $rightType);
+		if ($specifiedTypes !== null) {
+			return $specifiedTypes;
+		}
+
 		return $this->getShiftLeftTypeFromTypes($left, $right, $leftType, $rightType);
 	}
 
@@ -1820,6 +1844,12 @@ public function getShiftRightType(Expr $left, Expr $right, callable $getTypeCall
 		$leftType = $getTypeCallback($left);
 		$rightType = $getTypeCallback($right);
 
+		$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
+			->callOperatorTypeSpecifyingExtensions(new BinaryOp\ShiftRight($left, $right), $leftType, $rightType);
+		if ($specifiedTypes !== null) {
+			return $specifiedTypes;
+		}
+
 		return $this->getShiftRightTypeFromTypes($left, $right, $leftType, $rightType);
 	}
 
@@ -2034,6 +2064,12 @@ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType,
 	 */
 	private function resolveCommonMath(Expr\BinaryOp $expr, Type $leftType, Type $rightType): Type
 	{
+		$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
+			->callOperatorTypeSpecifyingExtensions($expr, $leftType, $rightType);
+		if ($specifiedTypes !== null) {
+			return $specifiedTypes;
+		}
+
 		$types = TypeCombinator::union($leftType, $rightType);
 		$leftNumberType = $leftType->toNumber();
 		$rightNumberType = $rightType->toNumber();
@@ -2073,12 +2109,6 @@ private function resolveCommonMath(Expr\BinaryOp $expr, Type $leftType, Type $ri
 			}
 		}
 
-		$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
-			->callOperatorTypeSpecifyingExtensions($expr, $leftType, $rightType);
-		if ($specifiedTypes !== null) {
-			return $specifiedTypes;
-		}
-
 		if (
 			$leftType->isArray()->yes()
 			|| $rightType->isArray()->yes()

tests/PHPStan/Analyser/OperatorTypeSpecifyingExtensionTypeInferenceTest.php

@@ -0,0 +1,36 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+class OperatorTypeSpecifyingExtensionTypeInferenceTest extends TypeInferenceTestCase
+{
+
+	public static function dataAsserts(): iterable
+	{
+		yield from self::gatherAssertTypes(__DIR__ . '/data/operator-type-specifying-extension.php');
+	}
+
+	/**
+	 * @param mixed ...$args
+	 */
+	#[DataProvider('dataAsserts')]
+	public function testAsserts(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return [
+			__DIR__ . '/operator-type-specifying-extension.neon',
+		];
+	}
+
+}

tests/PHPStan/Analyser/data/operator-type-specifying-extension.php

@@ -0,0 +1,65 @@
+<?php declare(strict_types = 1);
+
+namespace OperatorExtensionTest;
+
+use PHPStan\Fixture\TestBitwiseOperand;
+use PHPStan\Fixture\TestDecimal;
+use function PHPStan\Testing\assertType;
+
+// =============================================================================
+// Bitwise operator extension tests
+// =============================================================================
+
+function testBitwiseAnd(TestBitwiseOperand $a, TestBitwiseOperand $b): void
+{
+	assertType('PHPStan\Fixture\TestBitwiseOperand', $a & $b);
+}
+
+function testBitwiseOr(TestBitwiseOperand $a, TestBitwiseOperand $b): void
+{
+	assertType('PHPStan\Fixture\TestBitwiseOperand', $a | $b);
+}
+
+function testBitwiseXor(TestBitwiseOperand $a, TestBitwiseOperand $b): void
+{
+	assertType('PHPStan\Fixture\TestBitwiseOperand', $a ^ $b);
+}
+
+function testShiftLeft(TestBitwiseOperand $a, TestBitwiseOperand $b): void
+{
+	assertType('PHPStan\Fixture\TestBitwiseOperand', $a << $b);
+}
+
+function testShiftRight(TestBitwiseOperand $a, TestBitwiseOperand $b): void
+{
+	assertType('PHPStan\Fixture\TestBitwiseOperand', $a >> $b);
+}
+
+// =============================================================================
+// Arithmetic operator extension tests (via TestDecimal)
+// =============================================================================
+
+function testArithmeticAdd(TestDecimal $a, TestDecimal $b): void
+{
+	assertType('PHPStan\Fixture\TestDecimal', $a + $b);
+}
+
+function testArithmeticSub(TestDecimal $a, TestDecimal $b): void
+{
+	assertType('PHPStan\Fixture\TestDecimal', $a - $b);
+}
+
+function testArithmeticMul(TestDecimal $a, TestDecimal $b): void
+{
+	assertType('PHPStan\Fixture\TestDecimal', $a * $b);
+}
+
+function testArithmeticDiv(TestDecimal $a, TestDecimal $b): void
+{
+	assertType('PHPStan\Fixture\TestDecimal', $a / $b);
+}
+
+function testArithmeticPow(TestDecimal $a, TestDecimal $b): void
+{
+	assertType('PHPStan\Fixture\TestDecimal', $a ** $b);
+}

tests/PHPStan/Analyser/operator-type-specifying-extension.neon

@@ -0,0 +1,9 @@
+services:
+	-
+		class: PHPStan\Type\TestBitwiseOperatorTypeSpecifyingExtension
+		tags:
+			- phpstan.broker.operatorTypeSpecifyingExtension
+	-
+		class: PHPStan\Type\TestDecimalOperatorTypeSpecifyingExtension
+		tags:
+			- phpstan.broker.operatorTypeSpecifyingExtension

tests/PHPStan/Fixture/TestBitwiseOperand.php

@@ -0,0 +1,11 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Fixture;
+
+/**
+ * Test fixture for verifying bitwise operator type specifying extensions.
+ */
+final class TestBitwiseOperand
+{
+
+}

tests/PHPStan/Type/TestBitwiseOperatorTypeSpecifyingExtension.php

@@ -0,0 +1,28 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type;
+
+use PHPStan\Fixture\TestBitwiseOperand;
+use function in_array;
+
+/**
+ * Test extension for verifying that bitwise operators call type specifying extensions.
+ */
+final class TestBitwiseOperatorTypeSpecifyingExtension implements OperatorTypeSpecifyingExtension
+{
+
+	public function isOperatorSupported(string $operatorSigil, Type $leftSide, Type $rightSide): bool
+	{
+		$testType = new ObjectType(TestBitwiseOperand::class);
+
+		return in_array($operatorSigil, ['&', '|', '^', '<<', '>>'], true)
+			&& $testType->isSuperTypeOf($leftSide)->yes()
+			&& $testType->isSuperTypeOf($rightSide)->yes();
+	}
+
+	public function specifyType(string $operatorSigil, Type $leftSide, Type $rightSide): Type
+	{
+		return new ObjectType(TestBitwiseOperand::class);
+	}
+
+}