Improve specified type in comparisons

src/Analyser/TypeSpecifier.php

@@ -366,7 +366,8 @@ public function specifyTypesInCondition(
 			);
 
 		} elseif ($expr instanceof Node\Expr\BinaryOp\Smaller || $expr instanceof Node\Expr\BinaryOp\SmallerOrEqual) {
-			$offset = $expr instanceof Node\Expr\BinaryOp\Smaller ? 1 : 0;
+			$orEqual = $expr instanceof Node\Expr\BinaryOp\SmallerOrEqual;
+			$offset = $orEqual ? 0 : 1;
 			$leftType = $scope->getType($expr->left);
 			$rightType = $scope->getType($expr->right);
 
@@ -426,12 +427,6 @@ public function specifyTypesInCondition(
 						$context
 					));
 				}
-
-				$result = $result->unionWith($this->createRangeTypes(
-					$expr->right,
-					IntegerRangeType::fromInterval($leftType->getValue(), null, $offset),
-					$context
-				));
 			}
 
 			if ($rightType instanceof ConstantIntegerType) {
@@ -454,12 +449,46 @@ public function specifyTypesInCondition(
 						$context
 					));
 				}
+			}
 
-				$result = $result->unionWith($this->createRangeTypes(
-					$expr->left,
-					IntegerRangeType::fromInterval(null, $rightType->getValue(), -$offset),
-					$context
-				));
+			if ($context->truthy()) {
+				if (!$expr->left instanceof Node\Scalar) {
+					$result = $result->unionWith(
+						$this->create(
+							$expr->left,
+							$orEqual ? $rightType->getSmallerOrEqualType() : $rightType->getSmallerType(),
+							TypeSpecifierContext::createTruthy()
+						)
+					);
+				}
+				if (!$expr->right instanceof Node\Scalar) {
+					$result = $result->unionWith(
+						$this->create(
+							$expr->right,
+							$orEqual ? $leftType->getGreaterOrEqualType() : $leftType->getGreaterType(),
+							TypeSpecifierContext::createTruthy()
+						)
+					);
+				}
+			} elseif ($context->falsey()) {
+				if (!$expr->left instanceof Node\Scalar) {
+					$result = $result->unionWith(
+						$this->create(
+							$expr->left,
+							$orEqual ? $rightType->getGreaterType() : $rightType->getGreaterOrEqualType(),
+							TypeSpecifierContext::createTruthy()
+						)
+					);
+				}
+				if (!$expr->right instanceof Node\Scalar) {
+					$result = $result->unionWith(
+						$this->create(
+							$expr->right,
+							$orEqual ? $leftType->getSmallerType() : $leftType->getSmallerOrEqualType(),
+							TypeSpecifierContext::createTruthy()
+						)
+					);
+				}
 			}
 
 			return $result;

src/Type/Constant/ConstantBooleanType.php

@@ -4,6 +4,9 @@
 
 use PHPStan\Type\BooleanType;
 use PHPStan\Type\ConstantScalarType;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\NeverType;
+use PHPStan\Type\StaticTypeFactory;
 use PHPStan\Type\Traits\ConstantScalarTypeTrait;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
@@ -30,6 +33,38 @@ public function describe(VerbosityLevel $level): string
 		return $this->value ? 'true' : 'false';
 	}
 
+	public function getSmallerType(): Type
+	{
+		if ($this->value) {
+			return StaticTypeFactory::falsey();
+		}
+		return new NeverType();
+	}
+
+	public function getSmallerOrEqualType(): Type
+	{
+		if ($this->value) {
+			return new MixedType();
+		}
+		return StaticTypeFactory::falsey();
+	}
+
+	public function getGreaterType(): Type
+	{
+		if ($this->value) {
+			return new NeverType();
+		}
+		return StaticTypeFactory::truthy();
+	}
+
+	public function getGreaterOrEqualType(): Type
+	{
+		if ($this->value) {
+			return StaticTypeFactory::truthy();
+		}
+		return new MixedType();
+	}
+
 	public function toBoolean(): BooleanType
 	{
 		return $this;

src/Type/Constant/ConstantFloatType.php

@@ -6,6 +6,7 @@
 use PHPStan\Type\CompoundType;
 use PHPStan\Type\ConstantScalarType;
 use PHPStan\Type\FloatType;
+use PHPStan\Type\Traits\ConstantNumericComparisonTypeTrait;
 use PHPStan\Type\Traits\ConstantScalarTypeTrait;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
@@ -15,6 +16,7 @@ class ConstantFloatType extends FloatType implements ConstantScalarType
 
 	use ConstantScalarTypeTrait;
 	use ConstantScalarToBooleanTrait;
+	use ConstantNumericComparisonTypeTrait;
 
 	private float $value;
 

src/Type/Constant/ConstantIntegerType.php

@@ -7,6 +7,7 @@
 use PHPStan\Type\ConstantScalarType;
 use PHPStan\Type\IntegerRangeType;
 use PHPStan\Type\IntegerType;
+use PHPStan\Type\Traits\ConstantNumericComparisonTypeTrait;
 use PHPStan\Type\Traits\ConstantScalarTypeTrait;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
@@ -16,6 +17,7 @@ class ConstantIntegerType extends IntegerType implements ConstantScalarType
 
 	use ConstantScalarTypeTrait;
 	use ConstantScalarToBooleanTrait;
+	use ConstantNumericComparisonTypeTrait;
 
 	private int $value;
 

src/Type/Constant/ConstantStringType.php

@@ -14,12 +14,15 @@
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\Generic\GenericClassStringType;
 use PHPStan\Type\Generic\TemplateType;
+use PHPStan\Type\IntegerRangeType;
 use PHPStan\Type\MixedType;
+use PHPStan\Type\NullType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\StaticType;
 use PHPStan\Type\StringType;
 use PHPStan\Type\Traits\ConstantScalarTypeTrait;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\VerbosityLevel;
 
 class ConstantStringType extends StringType implements ConstantScalarType
@@ -299,6 +302,65 @@ public function generalize(): Type
 		return new StringType();
 	}
 
+	public function getSmallerType(): Type
+	{
+		$subtractedTypes = [
+			new ConstantBooleanType(true),
+			IntegerRangeType::createAllGreaterThanOrEqualTo((float) $this->value),
+		];
+
+		if ($this->value === '') {
+			$subtractedTypes[] = new NullType();
+			$subtractedTypes[] = new StringType();
+		}
+
+		if (!(bool) $this->value) {
+			$subtractedTypes[] = new ConstantBooleanType(false);
+		}
+
+		return TypeCombinator::remove(new MixedType(), TypeCombinator::union(...$subtractedTypes));
+	}
+
+	public function getSmallerOrEqualType(): Type
+	{
+		$subtractedTypes = [
+			IntegerRangeType::createAllGreaterThan((float) $this->value),
+		];
+
+		if (!(bool) $this->value) {
+			$subtractedTypes[] = new ConstantBooleanType(true);
+		}
+
+		return TypeCombinator::remove(new MixedType(), TypeCombinator::union(...$subtractedTypes));
+	}
+
+	public function getGreaterType(): Type
+	{
+		$subtractedTypes = [
+			new ConstantBooleanType(false),
+			IntegerRangeType::createAllSmallerThanOrEqualTo((float) $this->value),
+		];
+
+		if ((bool) $this->value) {
+			$subtractedTypes[] = new ConstantBooleanType(true);
+		}
+
+		return TypeCombinator::remove(new MixedType(), TypeCombinator::union(...$subtractedTypes));
+	}
+
+	public function getGreaterOrEqualType(): Type
+	{
+		$subtractedTypes = [
+			IntegerRangeType::createAllSmallerThan((float) $this->value),
+		];
+
+		if ((bool) $this->value) {
+			$subtractedTypes[] = new ConstantBooleanType(false);
+		}
+
+		return TypeCombinator::remove(new MixedType(), TypeCombinator::union(...$subtractedTypes));
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 * @return Type