Implement GMP operator type specifying extension#5223

Open

Firehed wants to merge 3 commits intophpstan:2.1.xfrom

Firehed:gmp-operator-type-extension

Contributor

Firehed commented Mar 15, 2026

Summary

Add GmpOperatorTypeSpecifyingExtension to properly infer return types for GMP operator overloads
GMP supports arithmetic (+, -, *, /, %, **), bitwise (&, |, ^, ~, <<, >>), and comparison operators
Extension only claims support when both operands are GMP-compatible (GMP, int, or numeric-string)
Update InitializerExprTypeResolver to call operator extensions early for object types

Fixes phpstan/phpstan#14288

Test plan

Added comprehensive test coverage in tests/PHPStan/Analyser/nsrt/gmp-operators.php
Tests cover GMP on both left and right sides of operators
Tests cover both operator overloads and corresponding gmp_* functions
All existing tests pass (11627 tests, 78892 assertions)

🤖 Generated with Claude Code

Collaborator

phpstan-bot commented Mar 15, 2026

You've opened the pull request against the latest branch 2.2.x. PHPStan 2.2 is not going to be released for months. If your code is relevant on 2.1.x and you want it to be released sooner, please rebase your pull request and change its target to 2.1.x.

Firehed force-pushed the gmp-operator-type-extension branch from a7b2630 to c75bac6 Compare

March 15, 2026 19:10

Firehed changed the base branch from 2.2.x to 2.1.x

March 15, 2026 19:10

VincentLanglet reviewed

View reviewed changes

src/Reflection/InitializerExprTypeResolver.php Outdated

Comment on lines +2065 to +2069

+              			$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
+              				->callOperatorTypeSpecifyingExtensions($expr, $leftType, $rightType);
+              			if ($specifiedTypes !== null) {
+              				return $specifiedTypes;
+              			}

Contributor

VincentLanglet Mar 15, 2026

This become a duplicate with the check later

$specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()
			->callOperatorTypeSpecifyingExtensions($expr, $leftType, $rightType);
		if ($specifiedTypes !== null) {
			return $specifiedTypes;
		}

I would either:

remove this and rely on the later call
or just move the existing call first with condition on object.

src/Reflection/InitializerExprTypeResolver.php Outdated

               		$leftType = $getTypeCallback($left);
               		$rightType = $getTypeCallback($right);
+              		if ($leftType->isObject()->yes() || $rightType->isObject()->yes()) {

Contributor

VincentLanglet Mar 15, 2026

This shouldn't check for Object and be done unconditionally.

src/Reflection/InitializerExprTypeResolver.php Outdated

               		$leftType = $getTypeCallback($left);
               		$rightType = $getTypeCallback($right);
+              		if ($leftType->isObject()->yes() || $rightType->isObject()->yes()) {

Contributor

VincentLanglet Mar 15, 2026

This shouldn't check for Object and be done unconditionally.

src/Reflection/InitializerExprTypeResolver.php Outdated

               		$leftType = $getTypeCallback($left);
               		$rightType = $getTypeCallback($right);
+              		if ($leftType->isObject()->yes() || $rightType->isObject()->yes()) {

Contributor

VincentLanglet Mar 15, 2026

This shouldn't check for Object and be done unconditionally.

src/Reflection/InitializerExprTypeResolver.php Outdated

Comment on lines +2619 to +2622

+              		// GMP supports unary minus and returns GMP
+              		if ($type->isObject()->yes() && (new ObjectType('GMP'))->isSuperTypeOf($type)->yes()) {
+              			return new ObjectType('GMP');
+              		}

Contributor

VincentLanglet Mar 15, 2026

Rather than an hardcoded check for this, I feel like it we should introduce an UnaryOperatorTypeSpecifyingExtension as explained here: #4980 (comment)

This is maybe better in a dedicated PR ?

src/Reflection/InitializerExprTypeResolver.php Outdated

               		$exprType = $getTypeCallback($expr);
+              		// GMP supports bitwise not and returns GMP
+              		if ($exprType->isObject()->yes() && (new ObjectType('GMP'))->isSuperTypeOf($exprType)->yes()) {

Contributor

VincentLanglet Mar 15, 2026

Same for UnaryOperatorTypeSpecifyingExtension

src/Type/Php/GmpOperatorTypeSpecifyingExtension.php Show resolved Hide resolved

Contributor Author

Firehed commented Mar 15, 2026

Updated to target 2.1 instead of 2.2 per the bot's suggestion. The two failing-as-of-writing tests appear to be failing on other PRs so I don't think they're specific to this change.

I'll check out the other feedback shortly. Thank you for the very quick review!

Member

ondrejmirtes commented Mar 15, 2026

Please introduce the changes to InitializerExprTypeResolver in a separate PR - this will force you to create synthetic extensions just for test purposes, and review these changes separately, which I want you to do.

Without this, if we once removed the GMP extensions then this feature would become untested.

After that is merged, then you can take advantage of it with new GMP extensions in a new PR.

Contributor Author

Firehed commented Mar 15, 2026

Can do. Thanks for the feedback!

Firehed mentioned this pull request

Call operator type specifying extensions for bitwise and arithmetic operators #5226

Merged

2 tasks

Contributor Author

Firehed commented Mar 15, 2026 •

edited

Loading

Split per feedback: #5226 contains the InitializerExprTypeResolver changes with synthetic test extensions. Once that's merged, I'll rebase this PR to only contain the GMP-specific extension (or new separate one if you prefer)

Firehed force-pushed the gmp-operator-type-extension branch from ade4b49 to 4442956 Compare

March 20, 2026 22:38

VincentLanglet reviewed

View reviewed changes

Contributor

VincentLanglet left a comment

Nice.

Now please again, split this PR in two:

One with the GmpOperatorTypeSpecifyingExtension
One with the unary minus, unary plus and bitwise not operator

Because for the second one, I think it will be a better API to introduce an UnaryOperatorTypeSpecifyingExtension

Contributor Author

Firehed commented Mar 20, 2026

Gotcha, will do. Missed your message before continuing.

Firehed mentioned this pull request

Introduce UnaryOperatorTypeSpecifyingExtension interface #5284

Merged

3 tasks

Contributor Author

Firehed commented Mar 23, 2026

@VincentLanglet #5284 sets up the UnaryOperatorTypeSpecifyingExtension; once that's looking good I'll update the GMP code to build on it instead.

Contributor

VincentLanglet commented Mar 24, 2026

@VincentLanglet #5284 sets up the UnaryOperatorTypeSpecifyingExtension; once that's looking good I'll update the GMP code to build on it instead.

It's merged, you can now rebase/update this PR :)

Firehed and others added 3 commits

March 24, 2026 09:04


          Add test coverage for GMP operator overloads and gmp_* functions

7da985c

This adds comprehensive type inference tests for GMP operations:

- Arithmetic operators (+, -, *, /, %, **) with GMP on left and right
- Bitwise operators (&, |, ^, ~, <<, >>) with GMP on left and right
- Comparison operators (<, <=, >, >=, ==, !=, <=>) with GMP on left and right
- Assignment operators (+=, -=, *=)
- Corresponding gmp_* functions (gmp_add, gmp_sub, gmp_mul, etc.)

These tests currently fail because PHPStan lacks a GmpOperatorTypeSpecifyingExtension
to specify that GMP operations return GMP rather than int|float.

Related: phpstan/phpstan#12123

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>


          Implement GMP operator type specifying extension

eb85b95

Add GmpOperatorTypeSpecifyingExtension to properly infer return types
for GMP operator overloads. GMP supports arithmetic (+, -, *, /, %, **),
bitwise (&, |, ^, ~, <<, >>), and comparison (<, <=, >, >=, ==, !=, <=>)
operators.

The extension only claims support when both operands are GMP-compatible
(GMP, int, or numeric-string). Operations with incompatible types like
stdClass are left to the default type inference.

Also update InitializerExprTypeResolver to call operator extensions
early for object types in resolveCommonMath and bitwise methods, and
add explicit GMP handling for unary operators (-$a, ~$a).

Fixes phpstan/phpstan#14288

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>


          Add GMP unary operator type specifying extension

eaebe39

Implements UnaryOperatorTypeSpecifyingExtension for GMP to handle
unary minus (-), unary plus (+), and bitwise NOT (~) operators.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Firehed force-pushed the gmp-operator-type-extension branch from aafd495 to eaebe39 Compare

March 24, 2026 16:19

Contributor Author

Firehed commented Mar 24, 2026

Alright @VincentLanglet I've done the rebase again, and now this is purely the GMP stuff leveraging the type overloading stuff from the previous two split-off PRs. It's still pretty much entirely Claude going at it, but it's now feeling pretty tightly-scoped from my perspective. LMK if there's anything else here :)

VincentLanglet reviewed

View reviewed changes

src/Type/Php/GmpOperatorTypeSpecifyingExtension.php

Comment on lines +33 to +39

+              		if (!$leftIsGmp && !$rightIsGmp) {
+              			return false;
+              		}
+              		// The other side must be GMP-compatible (GMP, int, or numeric-string)
+              		// GMP operations with incompatible types (like stdClass) will error at runtime
+              		return $this->isGmpCompatible($leftSide, $gmpType) && $this->isGmpCompatible($rightSide, $gmpType);

Contributor

VincentLanglet Mar 24, 2026 •

edited

Loading

Rather than not supporting when it's not compatible you could return an ErrorType.

I feel like you could do like BcMathNumberOperatorTypeSpecifyingExtension and

Not having a isGmpCompatible method
adding some checks in specifyType and returning an ErrorType

Except this feedback, this PR seems ok to me :)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet