Fix phpstan/phpstan#13023: function.alreadyNarrowedType and function.impossibleType after updates to 2.1.15

src/Rules/Comparison/ConstantConditionRuleHelper.php

@@ -57,7 +57,7 @@ private function shouldSkip(Scope $scope, Expr $expr): bool
 				|| $expr instanceof Expr\StaticCall
 			) && !$expr->isFirstClassCallable()
 		) {
-			$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $expr);
+			$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $expr, false);
 			if ($isAlways !== null) {
 				return true;
 			}

src/Rules/Comparison/ConstantLooseComparisonRule.php

@@ -42,6 +42,10 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
+		if (TraitContextHelper::isBinaryOpDependentOnTraitContext($scope, $node->left, $node->right)) {
+			return [];
+		}
+
 		$nodeType = $this->treatPhpDocTypesAsCertain ? $scope->getType($node) : $scope->getNativeType($node);
 		if (!$nodeType->isTrue()->yes() && !$nodeType->isFalse()->yes()) {
 			return [];

src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php

@@ -43,7 +43,7 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		$functionName = (string) $node->name;
-		$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $node);
+		$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $node, true);
 		if ($isAlways === null) {
 			return [];
 		}
@@ -53,7 +53,7 @@ public function processNode(Node $node, Scope $scope): array
 				return $this->possiblyImpureTipHelper->addTip($scope, $node, $ruleErrorBuilder);
 			}
 
-			$isAlways = $this->impossibleCheckTypeHelper->doNotTreatPhpDocTypesAsCertain()->findSpecifiedType($scope, $node);
+			$isAlways = $this->impossibleCheckTypeHelper->doNotTreatPhpDocTypesAsCertain()->findSpecifiedType($scope, $node, true);
 			if ($isAlways !== null) {
 				return $this->possiblyImpureTipHelper->addTip($scope, $node, $ruleErrorBuilder);
 			}

src/Rules/Comparison/ImpossibleCheckTypeHelper.php

@@ -61,6 +61,7 @@ public function __construct(
 	public function findSpecifiedType(
 		Scope $scope,
 		Expr $node,
+		bool $ignoreTraitContext,
 	): ?bool
 	{
 		if ($node instanceof FuncCall) {
@@ -198,6 +199,27 @@ public function findSpecifiedType(
 					}
 				} elseif ($functionName === 'method_exists' && $argsCount >= 2) {
 					$objectArg = $args[0]->value;
+
+					if (
+						$ignoreTraitContext
+						&& $this->isExpressionDependentOnTraitContext($scope, $objectArg)
+					) {
+						$traitReflection = $scope->getTraitReflection();
+						if ($traitReflection === null) {
+							return null;
+						}
+						$methodArgValue = $args[1]->value;
+						$methodArgType = $this->treatPhpDocTypesAsCertain ? $scope->getType($methodArgValue) : $scope->getNativeType($methodArgValue);
+						$constantMethodNames = $methodArgType->getConstantStrings();
+						if (count($constantMethodNames) === 0) {
+							return null;
+						}
+						foreach ($constantMethodNames as $constantMethodName) {
+							if (!$traitReflection->hasNativeMethod($constantMethodName->getValue())) {
+								return null;
+							}
+						}
+					}
 					$objectType = $this->treatPhpDocTypesAsCertain ? $scope->getType($objectArg) : $scope->getNativeType($objectArg);
 
 					if ($objectType instanceof ConstantStringType
@@ -310,6 +332,14 @@ public function findSpecifiedType(
 				continue;
 			}
 
+			if (
+				$ignoreTraitContext
+				&& $this->isExpressionDependentOnTraitContext($scope, $sureType[0])
+			) {
+				$results[] = TrinaryLogic::createMaybe();
+				continue;
+			}
+
 			if ($this->treatPhpDocTypesAsCertain) {
 				$argumentType = $scope->getType($sureType[0]);
 			} else {
@@ -336,6 +366,14 @@ public function findSpecifiedType(
 				continue;
 			}
 
+			if (
+				$ignoreTraitContext
+				&& $this->isExpressionDependentOnTraitContext($scope, $sureNotType[0])
+			) {
+				$results[] = TrinaryLogic::createMaybe();
+				continue;
+			}
+
 			if ($this->treatPhpDocTypesAsCertain) {
 				$argumentType = $scope->getType($sureNotType[0]);
 			} else {
@@ -356,6 +394,57 @@ public function findSpecifiedType(
 		return $result->maybe() ? null : $result->yes();
 	}
 
+	private function isExpressionDependentOnTraitContext(Scope $scope, Expr $expr): bool
+	{
+		if (!$scope->isInTrait()) {
+			return false;
+		}
+
+		if (self::isExpressionDependentOnThis($expr)) {
+			return true;
+		}
+
+		$classReflection = $scope->getClassReflection();
+		if ($classReflection === null) {
+			return false;
+		}
+
+		$type = $this->treatPhpDocTypesAsCertain ? $scope->getType($expr) : $scope->getNativeType($expr);
+		foreach ($type->getObjectClassNames() as $className) {
+			if ($className === $classReflection->getName()) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	private static function isExpressionDependentOnThis(Expr $expr): bool
+	{
+		if ($expr instanceof Expr\Variable && $expr->name === 'this') {
+			return true;
+		}
+
+		if ($expr instanceof Expr\PropertyFetch || $expr instanceof Expr\NullsafePropertyFetch) {
+			return self::isExpressionDependentOnThis($expr->var);
+		}
+
+		if ($expr instanceof Expr\MethodCall || $expr instanceof Expr\NullsafeMethodCall) {
+			return self::isExpressionDependentOnThis($expr->var);
+		}
+
+		if ($expr instanceof Expr\StaticPropertyFetch || $expr instanceof Expr\StaticCall) {
+			if ($expr->class instanceof Expr) {
+				return self::isExpressionDependentOnThis($expr->class);
+			}
+
+			$className = $expr->class->toString();
+			return in_array($className, ['self', 'static', 'parent'], true);
+		}
+
+		return false;
+	}
+
 	private static function isSpecified(Scope $scope, Expr $node, Expr $expr): bool
 	{
 		if ($expr === $node) {

src/Rules/Comparison/ImpossibleCheckTypeMethodCallRule.php

@@ -45,7 +45,7 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
-		$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $node);
+		$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $node, true);
 		if ($isAlways === null) {
 			return [];
 		}
@@ -55,7 +55,7 @@ public function processNode(Node $node, Scope $scope): array
 				return $this->possiblyImpureTipHelper->addTip($scope, $node, $ruleErrorBuilder);
 			}
 
-			$isAlways = $this->impossibleCheckTypeHelper->doNotTreatPhpDocTypesAsCertain()->findSpecifiedType($scope, $node);
+			$isAlways = $this->impossibleCheckTypeHelper->doNotTreatPhpDocTypesAsCertain()->findSpecifiedType($scope, $node, true);
 			if ($isAlways !== null) {
 				return $this->possiblyImpureTipHelper->addTip($scope, $node, $ruleErrorBuilder);
 			}

src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php

@@ -45,7 +45,7 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
-		$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $node);
+		$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $node, true);
 		if ($isAlways === null) {
 			return [];
 		}
@@ -55,7 +55,7 @@ public function processNode(Node $node, Scope $scope): array
 				return $this->possiblyImpureTipHelper->addTip($scope, $node, $ruleErrorBuilder);
 			}
 
-			$isAlways = $this->impossibleCheckTypeHelper->doNotTreatPhpDocTypesAsCertain()->findSpecifiedType($scope, $node);
+			$isAlways = $this->impossibleCheckTypeHelper->doNotTreatPhpDocTypesAsCertain()->findSpecifiedType($scope, $node, true);
 			if ($isAlways !== null) {
 				return $this->possiblyImpureTipHelper->addTip($scope, $node, $ruleErrorBuilder);
 			}

src/Rules/Comparison/NumberComparisonOperatorsConstantConditionRule.php

@@ -51,6 +51,10 @@ public function processNode(
 			return [];
 		}
 
+		if (TraitContextHelper::isBinaryOpDependentOnTraitContext($scope, $node->left, $node->right)) {
+			return [];
+		}
+
 		$exprType = $this->treatPhpDocTypesAsCertain ? $scope->getType($node) : $scope->getNativeType($node);
 		if ($exprType instanceof ConstantBooleanType) {
 			$addTip = function (RuleErrorBuilder $ruleErrorBuilder) use ($scope, $node): RuleErrorBuilder {

src/Rules/Comparison/StrictComparisonOfDifferentTypesRule.php

@@ -57,6 +57,10 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
+		if (TraitContextHelper::isBinaryOpDependentOnTraitContext($scope, $node->left, $node->right)) {
+			return [];
+		}
+
 		$nodeType = $nodeTypeResult->type;
 		if (!$nodeType instanceof ConstantBooleanType) {
 			return [];

src/Rules/Comparison/TraitContextHelper.php

@@ -0,0 +1,69 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Comparison;
+
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
+use function in_array;
+use function is_array;
+
+final class TraitContextHelper
+{
+
+	/**
+	 * Checks if a comparison expression's result may differ across different
+	 * class contexts when used inside a trait.
+	 *
+	 * Uses a deep traversal to find $this, self::, static::, or parent:: references
+	 * in any sub-expression.
+	 */
+	public static function isBinaryOpDependentOnTraitContext(Scope $scope, Expr $left, Expr $right): bool
+	{
+		if (!$scope->isInTrait()) {
+			return false;
+		}
+
+		return self::containsThisDependentExpression($left)
+			|| self::containsThisDependentExpression($right);
+	}
+
+	private static function containsThisDependentExpression(Expr $expr): bool
+	{
+		if ($expr instanceof Expr\Variable) {
+			return $expr->name === 'this';
+		}
+
+		if (
+			($expr instanceof Expr\StaticPropertyFetch || $expr instanceof Expr\StaticCall)
+			&& $expr->class instanceof Name
+		) {
+			$className = $expr->class->toString();
+			if (in_array($className, ['self', 'static', 'parent'], true)) {
+				return true;
+			}
+		}
+
+		foreach ($expr->getSubNodeNames() as $name) {
+			$subNode = $expr->$name;
+			if ($subNode instanceof Expr) {
+				if (self::containsThisDependentExpression($subNode)) {
+					return true;
+				}
+			} elseif (is_array($subNode)) {
+				foreach ($subNode as $item) {
+					if ($item instanceof Expr && self::containsThisDependentExpression($item)) {
+						return true;
+					}
+					if ($item instanceof Arg && self::containsThisDependentExpression($item->value)) {
+						return true;
+					}
+				}
+			}
+		}
+
+		return false;
+	}
+
+}

src/Type/Php/TypeSpecifyingFunctionsDynamicReturnTypeExtension.php

@@ -66,6 +66,7 @@ public function getTypeFromFunctionCall(
 		$isAlways = $this->getHelper()->findSpecifiedType(
 			$scope,
 			$functionCall,
+			false,
 		);
 		if ($isAlways === null) {
 			return null;

tests/PHPStan/Rules/Arrays/InvalidKeyInArrayDimFetchRuleTest.php

@@ -144,6 +144,12 @@ public function testBug12273(): void
 		]);
 	}
 
+	#[RequiresPhp('>= 8.1')]
+	public function testBug12798(): void
+	{
+		$this->analyse([__DIR__ . '/../Comparison/data/bug-12798.php'], []);
+	}
+
 	public function testBug12981(): void
 	{
 		$this->analyse([__DIR__ . '/data/bug-12981.php'], [

tests/PHPStan/Rules/Comparison/BooleanNotConstantConditionRuleTest.php

@@ -236,4 +236,10 @@ public function testBug6702(): void
 		$this->analyse([__DIR__ . '/data/bug-6702.php'], []);
 	}
 
+	public function testBug13023(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-13023.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php

@@ -187,14 +187,6 @@ public function testImpossibleCheckTypeFunctionCall(): void
 					'Call to function method_exists() with $this(CheckTypeFunctionCall\MethodExistsWithTrait) and \'method\' will always evaluate to true.',
 					650,
 				],
-				[
-					'Call to function method_exists() with $this(CheckTypeFunctionCall\MethodExistsWithTrait) and \'someAnother\' will always evaluate to true.',
-					653,
-				],
-				[
-					'Call to function method_exists() with $this(CheckTypeFunctionCall\MethodExistsWithTrait) and \'unknown\' will always evaluate to false.',
-					656,
-				],
 				[
 					'Call to function method_exists() with \'CheckTypeFunctionCall\\\\MethodExistsWithTrait\' and \'method\' will always evaluate to true.',
 					659,
@@ -1207,4 +1199,51 @@ public function testBug13799(): void
 		]);
 	}
 
+	public function testBug13023(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-13023.php'], [
+			[
+				'Call to function is_int() with 0 will always evaluate to true.',
+				198,
+			],
+			[
+				'Call to function is_int() with int<1, max> will always evaluate to true.',
+				198,
+			],
+		]);
+	}
+
+	#[RequiresPhp('>= 8.1')]
+	public function testBug7599(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-7599.php'], []);
+	}
+
+	public function testBug9095(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-9095.php'], []);
+	}
+
+	public function testBug13474(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-13474.php'], []);
+	}
+
+	public function testBug13687(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-13687.php'], []);
+	}
+
+	#[RequiresPhp('>= 8.1')]
+	public function testBug12798(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-12798.php'], []);
+	}
+
 }