Keep specifying types for CallLikes resolving to ConstantTypes

Author: herndlm

src/Analyser/TypeSpecifier.php

@@ -167,10 +167,6 @@ public function specifyTypesInCondition(
 				return $this->create($exprNode, new ObjectWithoutClassType(), $context, false, $scope);
 			}
 		} elseif ($expr instanceof Node\Expr\BinaryOp\Identical) {
-			if ($expr->left instanceof Expr\CallLike && $expr->right instanceof Expr\CallLike) {
-				return new SpecifiedTypes();
-			}
-
 			$expressions = $this->findTypeExpressionsFromBinaryOperation($scope, $expr);
 			if ($expressions !== null) {
 				/** @var Expr $exprNode */
@@ -263,6 +259,12 @@ public function specifyTypesInCondition(
 				);
 			}
 
+			$exprLeftType = $scope->getType($expr->left);
+			$exprRightType = $scope->getType($expr->right);
+			if ($expr->left instanceof Expr\CallLike && $expr->right instanceof Expr\CallLike && !$exprLeftType instanceof ConstantType && !$exprRightType instanceof ConstantType) {
+				return new SpecifiedTypes();
+			}
+
 			if ($context->true()) {
 				$type = TypeCombinator::intersect($scope->getType($expr->right), $scope->getType($expr->left));
 				$leftTypes = $this->create($expr->left, $type, $context, false, $scope);
@@ -279,9 +281,6 @@ public function specifyTypesInCondition(
 					return $leftTypes->unionWith($rightTypes);
 				}
 
-				$exprLeftType = $scope->getType($expr->left);
-				$exprRightType = $scope->getType($expr->right);
-
 				$types = null;
 
 				if (
@@ -333,10 +332,6 @@ public function specifyTypesInCondition(
 				$context,
 			);
 		} elseif ($expr instanceof Node\Expr\BinaryOp\Equal) {
-			if ($expr->left instanceof Expr\CallLike && $expr->right instanceof Expr\CallLike) {
-				return new SpecifiedTypes();
-			}
-
 			$expressions = $this->findTypeExpressionsFromBinaryOperation($scope, $expr);
 			if ($expressions !== null) {
 				/** @var Expr $exprNode */
@@ -362,6 +357,9 @@ public function specifyTypesInCondition(
 
 			$leftType = $scope->getType($expr->left);
 			$rightType = $scope->getType($expr->right);
+			if ($expr->left instanceof Expr\CallLike && $expr->right instanceof Expr\CallLike && !$leftType instanceof ConstantType && !$rightType instanceof ConstantType) {
+				return new SpecifiedTypes();
+			}
 
 			$leftBooleanType = $leftType->toBoolean();
 			if ($leftBooleanType instanceof ConstantBooleanType && $rightType instanceof BooleanType) {

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeMethodCallRuleTest.php

@@ -80,6 +80,10 @@ public function testRule(): void
 				'Call to method ImpossibleMethodCall\Foo::isSame() with *NEVER* and stdClass will always evaluate to false.',
 				84,
 			],
+			[
+				'Call to method ImpossibleMethodCall\Foo::isSame() with \'foo\' and \'foo\' will always evaluate to true.',
+				101,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Comparison/data/impossible-method-call.php

@@ -98,12 +98,10 @@ public function doDolor(\stdClass $std1, \stdClass $std2)
 		if ($this->isNotSame(self::createStdClass('b'), self::createStdClass('b'))) {
 
 		}
-		$std3 = new \stdClass();
-		if ($this->isSame($std3, self::createStdClass('c'))) {
+		if ($this->isSame(self::returnFoo(), self::returnFoo())) {
 
 		}
-		$std4 = new \stdClass();
-		if ($this->isNotSame($std4, self::createStdClass('d'))) {
+		if ($this->isNotSame(self::returnFoo(), self::returnFoo())) {
 
 		}
 	}
@@ -118,4 +116,12 @@ public static function createStdClass(string $foo): \stdClass
 		return new \stdClass();
 	}
 
+	/**
+	 * @return 'foo'
+	 */
+	public static function returnFoo(): string
+	{
+		return 'foo';
+	}
+
 }