Narrow to decimal-int-string/non-decimal-int-string from (string) (int) $x === $x comparisons

- Add a special case to `TypeSpecifier::resolveNormalizedIdentical()` that detects
  the canonical decimal-int round-trip `(string) (int) $x === $x` (the same check
  `ConstantStringType::isDecimalIntegerString()` performs) and narrows `$x`.
- In the truthy branch `$x` is intersected with `AccessoryDecimalIntegerStringType`
  (`decimal-int-string`); in the falsey branch with its inverse
  (`non-decimal-int-string`). The truthy direction already worked through the
  generic identical fallback, but the falsey direction did not because the
  accessory type is non-removeable.
- Detection is symmetric in operand order and recognizes both the cast forms and
  the `strval()`/`intval()` function forms, in any mix (`strval((int) $x)`,
  `(string) intval($x)`, ...), via the new `getStringCastedExpr()` /
  `getIntCastedExpr()` helpers.
- Narrowing is only applied when the compared expression is already known to be a
  string, so `int|string` operands keep their int part in the falsey branch.

Author: phpstan-bot

src/Analyser/TypeSpecifier.php

@@ -37,6 +37,7 @@
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Accessory\AccessoryArrayListType;
+use PHPStan\Type\Accessory\AccessoryDecimalIntegerStringType;
 use PHPStan\Type\Accessory\AccessoryLowercaseStringType;
 use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
 use PHPStan\Type\Accessory\AccessoryNonFalsyStringType;
@@ -2960,6 +2961,60 @@ public function resolveIdentical(Expr\BinaryOp\Identical $expr, Scope $scope, Ty
 		return $specifiedTypes;
 	}
 
+	/**
+	 * Returns the inner expression E when $expr casts E to a string and back to an int,
+	 * i.e. `(string) (int) E`, `strval(intval(E))` or any mix of the cast/function forms.
+	 * This is the canonical "decimal integer string" round-trip that
+	 * ConstantStringType::isDecimalIntegerString() checks with `(string) (int) $value === $value`.
+	 */
+	private function getDecimalIntegerStringCastedExpr(Expr $expr): ?Expr
+	{
+		$intCasted = $this->getStringCastedExpr($expr);
+		if ($intCasted === null) {
+			return null;
+		}
+
+		return $this->getIntCastedExpr($intCasted);
+	}
+
+	private function getStringCastedExpr(Expr $expr): ?Expr
+	{
+		if ($expr instanceof Expr\Cast\String_) {
+			return $expr->expr;
+		}
+
+		if (
+			$expr instanceof FuncCall
+			&& $expr->name instanceof Name
+			&& !$expr->isFirstClassCallable()
+			&& strtolower($expr->name->toString()) === 'strval'
+			&& count($expr->getArgs()) === 1
+		) {
+			return $expr->getArgs()[0]->value;
+		}
+
+		return null;
+	}
+
+	private function getIntCastedExpr(Expr $expr): ?Expr
+	{
+		if ($expr instanceof Expr\Cast\Int_) {
+			return $expr->expr;
+		}
+
+		if (
+			$expr instanceof FuncCall
+			&& $expr->name instanceof Name
+			&& !$expr->isFirstClassCallable()
+			&& strtolower($expr->name->toString()) === 'intval'
+			&& count($expr->getArgs()) === 1
+		) {
+			return $expr->getArgs()[0]->value;
+		}
+
+		return null;
+	}
+
 	private function resolveNormalizedIdentical(Expr\BinaryOp\Identical $expr, Scope $scope, TypeSpecifierContext $context): SpecifiedTypes
 	{
 		$leftExpr = $expr->left;
@@ -3222,6 +3277,37 @@ private function resolveNormalizedIdentical(Expr\BinaryOp\Identical $expr, Scope
 			}
 		}
 
+		// (string) (int) $x === $x  (and the strval(intval()) equivalents)
+		if (!$context->null()) {
+			$leftCastedExpr = $this->getDecimalIntegerStringCastedExpr($unwrappedLeftExpr);
+			$rightCastedExpr = $this->getDecimalIntegerStringCastedExpr($unwrappedRightExpr);
+
+			$decimalValueExpr = null;
+			if (
+				$leftCastedExpr !== null
+				&& $this->exprPrinter->printExpr($leftCastedExpr) === $this->exprPrinter->printExpr($unwrappedRightExpr)
+			) {
+				$decimalValueExpr = $unwrappedRightExpr;
+			} elseif (
+				$rightCastedExpr !== null
+				&& $this->exprPrinter->printExpr($rightCastedExpr) === $this->exprPrinter->printExpr($unwrappedLeftExpr)
+			) {
+				$decimalValueExpr = $unwrappedLeftExpr;
+			}
+
+			if ($decimalValueExpr !== null) {
+				$decimalValueType = $scope->getType($decimalValueExpr);
+				if ($decimalValueType->isString()->yes()) {
+					return $this->create(
+						$decimalValueExpr,
+						TypeCombinator::intersect($decimalValueType, new AccessoryDecimalIntegerStringType($context->falsey())),
+						TypeSpecifierContext::createTruthy(),
+						$scope,
+					)->setRootExpr($expr);
+				}
+			}
+		}
+
 		if ($rightType->isString()->yes()) {
 			$types = null;
 			foreach ($rightType->getConstantStrings() as $constantString) {

tests/PHPStan/Analyser/nsrt/decimal-int-string-cast.php

@@ -0,0 +1,69 @@
+<?php declare(strict_types = 1);
+
+namespace DecimalIntStringCast;
+
+use function PHPStan\Testing\assertType;
+use function intval;
+use function strval;
+
+class Foo
+{
+
+	public function castIdentical(string $s): void
+	{
+		if ((string) (int) $s === $s) {
+			assertType('decimal-int-string', $s);
+		} else {
+			assertType('non-decimal-int-string', $s);
+		}
+	}
+
+	public function castIdenticalFlipped(string $s): void
+	{
+		if ($s === (string) (int) $s) {
+			assertType('decimal-int-string', $s);
+		} else {
+			assertType('non-decimal-int-string', $s);
+		}
+	}
+
+	public function castNotIdentical(string $s): void
+	{
+		if ((string) (int) $s !== $s) {
+			assertType('non-decimal-int-string', $s);
+		} else {
+			assertType('decimal-int-string', $s);
+		}
+	}
+
+	public function strvalIntval(string $s): void
+	{
+		if (strval(intval($s)) === $s) {
+			assertType('decimal-int-string', $s);
+		} else {
+			assertType('non-decimal-int-string', $s);
+		}
+	}
+
+	public function mixedCastForms(string $s): void
+	{
+		if (strval((int) $s) === $s) {
+			assertType('decimal-int-string', $s);
+		}
+
+		if ((string) intval($s) === $s) {
+			assertType('decimal-int-string', $s);
+		}
+	}
+
+	public function notAlwaysString(int|string $s): void
+	{
+		if ((string) (int) $s === $s) {
+			assertType('decimal-int-string', $s);
+		} else {
+			// $s can still be an int here, so we cannot narrow to non-decimal-int-string
+			assertType('int|string', $s);
+		}
+	}
+
+}