Do not report non-falsy-string == 0 as always false in AccessoryNonFalsyStringType::looseCompare()

src/Type/Accessory/AccessoryNonFalsyStringType.php

@@ -13,14 +13,15 @@
 use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\Constant\ConstantIntegerType;
+use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\FloatType;
 use PHPStan\Type\GeneralizePrecision;
 use PHPStan\Type\IntegerType;
 use PHPStan\Type\IntersectionType;
 use PHPStan\Type\IsSuperTypeOfResult;
+use PHPStan\Type\NullType;
 use PHPStan\Type\ObjectWithoutClassType;
-use PHPStan\Type\StaticTypeFactory;
 use PHPStan\Type\StringType;
 use PHPStan\Type\Traits\MaybeCallableTypeTrait;
 use PHPStan\Type\Traits\NonArrayTypeTrait;
@@ -347,8 +348,13 @@
 
 	public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType
 	{
-		$falseyTypes = StaticTypeFactory::falsey();
-		if ($falseyTypes->isSuperTypeOf($type)->yes()) {
+		$dominated = TypeCombinator::union(
+			new NullType(),
+			new ConstantBooleanType(false),
+			new ConstantStringType(''),
+			new ConstantArrayType([], []),
+		);
+		if ($dominated->isSuperTypeOf($type)->yes()) {
 			return new ConstantBooleanType(false);
 		}
 

tests/PHPStan/Analyser/nsrt/loose-comparisons.php

@@ -561,10 +561,12 @@ public function sayNonFalsyStr(
 		assertType('bool', $nonFalsyString == $true);
 		assertType('false', $nonFalsyString == $false);
 		assertType('bool', $nonFalsyString == $one);
-		assertType('false', $nonFalsyString == $zero);
+		assertType('bool', $nonFalsyString == $zero); // e.g. '0.0' == 0 is true (non-falsy numeric string compared numerically)
+		assertType('true', '0.0' == 0);
 		assertType('bool', $nonFalsyString == $minusOne);
 		assertType('bool', $nonFalsyString == $oneStr);
-		assertType('false', $nonFalsyString == $zeroStr);
+		assertType('bool', $nonFalsyString == $zeroStr); // e.g. '0.0' == '0' is true (numeric strings compared numerically)
+		assertType('true', '0.0' == '0');
 		assertType('bool', $nonFalsyString == $minusOneStr);
 		assertType('bool', $nonFalsyString == $plusOneStr);
 		assertType('false', $nonFalsyString == $null);

tests/PHPStan/Rules/Comparison/ConstantLooseComparisonRuleTest.php

@@ -248,4 +248,34 @@ public function testBug13098(): void
 		$this->analyse([__DIR__ . '/data/bug-13098.php'], []);
 	}
 
+	public function testBug14606(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-14606.php'], [
+			[
+				'Loose comparison using == between non-falsy-string and false will always evaluate to false.',
+				19,
+				'Because the type is coming from a PHPDoc, you can turn off this check by setting <fg=cyan>treatPhpDocTypesAsCertain: false</> in your <fg=cyan>%configurationFile%</>.',
+			],
+			[
+				'Loose comparison using == between non-falsy-string and null will always evaluate to false.',
+				24,
+				'Because the type is coming from a PHPDoc, you can turn off this check by setting <fg=cyan>treatPhpDocTypesAsCertain: false</> in your <fg=cyan>%configurationFile%</>.',
+			],
+			[
+				"Loose comparison using == between non-falsy-string and '' will always evaluate to false.",
+				29,
+				'Because the type is coming from a PHPDoc, you can turn off this check by setting <fg=cyan>treatPhpDocTypesAsCertain: false</> in your <fg=cyan>%configurationFile%</>.',
+			],
+			[
+				'Loose comparison using == between non-falsy-string and array{} will always evaluate to false.',
+				34,
+			],
+			[
+				'Loose comparison using == between non-falsy-string and false|null will always evaluate to false.',
+				42,
+				'Because the type is coming from a PHPDoc, you can turn off this check by setting <fg=cyan>treatPhpDocTypesAsCertain: false</> in your <fg=cyan>%configurationFile%</>.',
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Comparison/data/bug-14606.php

@@ -0,0 +1,43 @@
+<?php declare(strict_types = 1);
+
+namespace Bug14606;
+
+function nonFalsyStringLooseCompareInt(string $x): bool {
+	return !empty($x) && $x == 0; // may be true if $x is '0.0'
+}
+
+function nonFalsyStringLooseCompareFloat(string $x): bool {
+	return !empty($x) && $x == 0.0; // may be true if $x is '0.0'
+}
+
+function nonFalsyStringLooseCompareZeroString(string $x): bool {
+	return !empty($x) && $x == '0'; // may be true if $x is '0.0' (numeric strings compared numerically)
+}
+
+/** @param non-falsy-string $x */
+function nonFalsyStringLooseCompareFalse(string $x): bool {
+	return $x == false; // always false: (bool)non-falsy-string is true
+}
+
+/** @param non-falsy-string $x */
+function nonFalsyStringLooseCompareNull(string $x): bool {
+	return $x == null; // always false: non-falsy-string is non-empty
+}
+
+/** @param non-falsy-string $x */
+function nonFalsyStringLooseCompareEmptyString(string $x): bool {
+	return $x == ''; // always false: non-falsy-string is non-empty
+}
+
+/** @param non-falsy-string $x */
+function nonFalsyStringLooseCompareEmptyArray(string $x): bool {
+	return $x == []; // always false
+}
+
+/**
+ * @param non-falsy-string $x
+ * @param null|false $nullOrFalse
+ */
+function nonFalsyStringLooseCompareNullOrFalse(string $x, $nullOrFalse): bool {
+	return $x == $nullOrFalse; // always false
+}