Add PhpVersion param

VincentLanglet · VincentLanglet · commit eab37889d83b · 2024-09-25T00:22:53.000+02:00
diff --git a/src/Analyser/MutatingScope.php b/src/Analyser/MutatingScope.php
@@ -751,15 +751,15 @@ private function resolveType(string $exprString, Expr $node): Type
 		}
 
 		if ($node instanceof Expr\BinaryOp\SmallerOrEqual) {
-			return $this->getType($node->left)->isSmallerThanOrEqual($this->getType($node->right))->toBooleanType();
+			return $this->getType($node->left)->isSmallerThanOrEqual($this->getType($node->right), $this->phpVersion)->toBooleanType();
 		}
 
 		if ($node instanceof Expr\BinaryOp\Greater) {
 			return $this->getType($node->right)->isSmallerThan($this->getType($node->left))->toBooleanType();
 		}
 
 		if ($node instanceof Expr\BinaryOp\GreaterOrEqual) {
-			return $this->getType($node->right)->isSmallerThanOrEqual($this->getType($node->left))->toBooleanType();
+			return $this->getType($node->right)->isSmallerThanOrEqual($this->getType($node->left), $this->phpVersion)->toBooleanType();
 		}
 
 		if ($node instanceof Expr\BinaryOp\Equal) {
diff --git a/src/Reflection/InitializerExprTypeResolver.php b/src/Reflection/InitializerExprTypeResolver.php
@@ -320,15 +320,15 @@ public function getType(Expr $expr, InitializerExprContext $context): Type
 		}
 
 		if ($expr instanceof Expr\BinaryOp\SmallerOrEqual) {
-			return $this->getType($expr->left, $context)->isSmallerThanOrEqual($this->getType($expr->right, $context))->toBooleanType();
+			return $this->getType($expr->left, $context)->isSmallerThanOrEqual($this->getType($expr->right, $context), $this->phpVersion)->toBooleanType();
 		}
 
 		if ($expr instanceof Expr\BinaryOp\Greater) {
 			return $this->getType($expr->right, $context)->isSmallerThan($this->getType($expr->left, $context))->toBooleanType();
 		}
 
 		if ($expr instanceof Expr\BinaryOp\GreaterOrEqual) {
-			return $this->getType($expr->right, $context)->isSmallerThanOrEqual($this->getType($expr->left, $context))->toBooleanType();
+			return $this->getType($expr->right, $context)->isSmallerThanOrEqual($this->getType($expr->left, $context), $this->phpVersion)->toBooleanType();
 		}
 
 		if ($expr instanceof Expr\BinaryOp\LogicalXor) {
diff --git a/src/Type/CompoundType.php b/src/Type/CompoundType.php
@@ -2,6 +2,7 @@
 
 namespace PHPStan\Type;
 
+use PHPStan\Php\PhpVersion;
 use PHPStan\TrinaryLogic;
 
 /** @api */
@@ -16,6 +17,6 @@ public function isAcceptedWithReasonBy(Type $acceptingType, bool $strictTypes):
 
 	public function isGreaterThan(Type $otherType): TrinaryLogic;
 
-	public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic;
+	public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic;
 
 }
diff --git a/src/Type/Enum/EnumCaseObjectType.php b/src/Type/Enum/EnumCaseObjectType.php
@@ -2,6 +2,7 @@
 
 namespace PHPStan\Type\Enum;
 
+use PHPStan\Php\PhpVersion;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;
 use PHPStan\PhpDocParser\Ast\Type\ConstTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\TypeNode;
@@ -184,7 +185,7 @@ public function isSmallerThan(Type $otherType): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
 		return TrinaryLogic::createNo();
 	}
diff --git a/src/Type/IntegerRangeType.php b/src/Type/IntegerRangeType.php
@@ -325,18 +325,18 @@ public function isSmallerThan(Type $otherType): TrinaryLogic
 		return TrinaryLogic::extremeIdentity($minIsSmaller, $maxIsSmaller);
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
 		if ($this->min === null) {
 			$minIsSmaller = TrinaryLogic::createYes();
 		} else {
-			$minIsSmaller = (new ConstantIntegerType($this->min))->isSmallerThanOrEqual($otherType);
+			$minIsSmaller = (new ConstantIntegerType($this->min))->isSmallerThanOrEqual($otherType, $phpVersion);
 		}
 
 		if ($this->max === null) {
 			$maxIsSmaller = TrinaryLogic::createNo();
 		} else {
-			$maxIsSmaller = (new ConstantIntegerType($this->max))->isSmallerThanOrEqual($otherType);
+			$maxIsSmaller = (new ConstantIntegerType($this->max))->isSmallerThanOrEqual($otherType, $phpVersion);
 		}
 
 		return TrinaryLogic::extremeIdentity($minIsSmaller, $maxIsSmaller);
@@ -359,18 +359,18 @@ public function isGreaterThan(Type $otherType): TrinaryLogic
 		return TrinaryLogic::extremeIdentity($minIsSmaller, $maxIsSmaller);
 	}
 
-	public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic
+	public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
 		if ($this->min === null) {
 			$minIsSmaller = TrinaryLogic::createNo();
 		} else {
-			$minIsSmaller = $otherType->isSmallerThanOrEqual((new ConstantIntegerType($this->min)));
+			$minIsSmaller = $otherType->isSmallerThanOrEqual((new ConstantIntegerType($this->min)), $phpVersion);
 		}
 
 		if ($this->max === null) {
 			$maxIsSmaller = TrinaryLogic::createYes();
 		} else {
-			$maxIsSmaller = $otherType->isSmallerThanOrEqual((new ConstantIntegerType($this->max)));
+			$maxIsSmaller = $otherType->isSmallerThanOrEqual((new ConstantIntegerType($this->max)), $phpVersion);
 		}
 
 		return TrinaryLogic::extremeIdentity($minIsSmaller, $maxIsSmaller);
diff --git a/src/Type/IntersectionType.php b/src/Type/IntersectionType.php
@@ -807,9 +807,9 @@ public function isSmallerThan(Type $otherType): TrinaryLogic
 		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThan($otherType));
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
-		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThanOrEqual($otherType));
+		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThanOrEqual($otherType, $phpVersion));
 	}
 
 	public function isNull(): TrinaryLogic
@@ -881,9 +881,9 @@ public function isGreaterThan(Type $otherType): TrinaryLogic
 		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThan($type));
 	}
 
-	public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic
+	public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
-		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThanOrEqual($type));
+		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThanOrEqual($type, $phpVersion));
 	}
 
 	public function getSmallerType(): Type
diff --git a/src/Type/NullType.php b/src/Type/NullType.php
@@ -121,14 +121,14 @@ public function isSmallerThan(Type $otherType): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
 		if ($otherType instanceof ConstantScalarType) {
 			return TrinaryLogic::createFromBoolean(null <= $otherType->getValue());
 		}
 
 		if ($otherType instanceof CompoundType) {
-			return $otherType->isGreaterThanOrEqual($this);
+			return $otherType->isGreaterThanOrEqual($this, $phpVersion);
 		}
 
 		return TrinaryLogic::createMaybe();
diff --git a/src/Type/Traits/ConstantScalarTypeTrait.php b/src/Type/Traits/ConstantScalarTypeTrait.php
@@ -91,14 +91,14 @@ public function isSmallerThan(Type $otherType): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
 		if ($otherType instanceof ConstantScalarType) {
 			return TrinaryLogic::createFromBoolean($this->value <= $otherType->getValue());
 		}
 
 		if ($otherType instanceof CompoundType) {
-			return $otherType->isGreaterThanOrEqual($this);
+			return $otherType->isGreaterThanOrEqual($this, $phpVersion);
 		}
 
 		return TrinaryLogic::createMaybe();
diff --git a/src/Type/Traits/LateResolvableTypeTrait.php b/src/Type/Traits/LateResolvableTypeTrait.php
@@ -372,9 +372,9 @@ public function isSmallerThan(Type $otherType): TrinaryLogic
 		return $this->resolve()->isSmallerThan($otherType);
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
-		return $this->resolve()->isSmallerThanOrEqual($otherType);
+		return $this->resolve()->isSmallerThanOrEqual($otherType, $phpVersion);
 	}
 
 	public function isNull(): TrinaryLogic
@@ -550,15 +550,15 @@ public function isGreaterThan(Type $otherType): TrinaryLogic
 		return $otherType->isSmallerThan($result);
 	}
 
-	public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic
+	public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
 		$result = $this->resolve();
 
 		if ($result instanceof CompoundType) {
-			return $result->isGreaterThanOrEqual($otherType);
+			return $result->isGreaterThanOrEqual($otherType, $phpVersion);
 		}
 
-		return $otherType->isSmallerThanOrEqual($result);
+		return $otherType->isSmallerThanOrEqual($result, $phpVersion);
 	}
 
 	public function exponentiate(Type $exponent): Type
diff --git a/src/Type/Traits/UndecidedComparisonCompoundTypeTrait.php b/src/Type/Traits/UndecidedComparisonCompoundTypeTrait.php
@@ -2,6 +2,7 @@
 
 namespace PHPStan\Type\Traits;
 
+use PHPStan\Php\PhpVersion;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Type;
 
@@ -15,7 +16,7 @@ public function isGreaterThan(Type $otherType): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
-	public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic
+	public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
 		return TrinaryLogic::createMaybe();
 	}
diff --git a/src/Type/Traits/UndecidedComparisonTypeTrait.php b/src/Type/Traits/UndecidedComparisonTypeTrait.php
@@ -2,6 +2,7 @@
 
 namespace PHPStan\Type\Traits;
 
+use PHPStan\Php\PhpVersion;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
@@ -14,7 +15,7 @@ public function isSmallerThan(Type $otherType): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
 		return TrinaryLogic::createMaybe();
 	}
diff --git a/src/Type/Type.php b/src/Type/Type.php
@@ -217,7 +217,7 @@ public function toArrayKey(): Type;
 
 	public function isSmallerThan(Type $otherType): TrinaryLogic;
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic;
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic;
 
 	/**
 	 * Is Type of a known constant value? Includes literal strings, integers, floats, true, false, null, and array shapes.
diff --git a/src/Type/UnionType.php b/src/Type/UnionType.php
@@ -788,9 +788,9 @@ public function isSmallerThan(Type $otherType): TrinaryLogic
 		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThan($otherType));
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
-		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThanOrEqual($otherType));
+		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThanOrEqual($otherType, $phpVersion));
 	}
 
 	public function isNull(): TrinaryLogic
@@ -868,9 +868,9 @@ public function isGreaterThan(Type $otherType): TrinaryLogic
 		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThan($type));
 	}
 
-	public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic
+	public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic
 	{
-		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThanOrEqual($type));
+		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThanOrEqual($type, $phpVersion));
 	}
 
 	public function toBoolean(): BooleanType
diff --git a/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php b/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php
@@ -5,6 +5,7 @@
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider;
+use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\ClassMemberAccessAnswerer;
 use PHPStan\Reflection\ExtendedMethodReflection;
 use PHPStan\Reflection\FunctionReflection;
@@ -252,7 +253,7 @@ public function isSmallerThan(Type $otherType): \PHPStan\TrinaryLogic
 		// TODO: Implement isSmallerThan() method.
 	}
 
-	public function isSmallerThanOrEqual(Type $otherType): \PHPStan\TrinaryLogic
+	public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): \PHPStan\TrinaryLogic
 	{
 		// TODO: Implement isSmallerThanOrEqual() method.
 	}

Original file line number	Diff line number	Diff line change
`@@ -751,15 +751,15 @@ private function resolveType(string $exprString, Expr $node): Type`
`751`	`751`	`}`
`752`	`752`
`753`	`753`	`if ($node instanceof Expr\BinaryOp\SmallerOrEqual) {`
`754`		`- return $this->getType($node->left)->isSmallerThanOrEqual($this->getType($node->right))->toBooleanType();`
	`754`	`+ return $this->getType($node->left)->isSmallerThanOrEqual($this->getType($node->right), $this->phpVersion)->toBooleanType();`
`755`	`755`	`}`
`756`	`756`
`757`	`757`	`if ($node instanceof Expr\BinaryOp\Greater) {`
`758`	`758`	`return $this->getType($node->right)->isSmallerThan($this->getType($node->left))->toBooleanType();`
`759`	`759`	`}`
`760`	`760`
`761`	`761`	`if ($node instanceof Expr\BinaryOp\GreaterOrEqual) {`
`762`		`- return $this->getType($node->right)->isSmallerThanOrEqual($this->getType($node->left))->toBooleanType();`
	`762`	`+ return $this->getType($node->right)->isSmallerThanOrEqual($this->getType($node->left), $this->phpVersion)->toBooleanType();`
`763`	`763`	`}`
`764`	`764`
`765`	`765`	`if ($node instanceof Expr\BinaryOp\Equal) {`
Original file line number	Diff line number	Diff line change
`@@ -320,15 +320,15 @@ public function getType(Expr $expr, InitializerExprContext $context): Type`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`if ($expr instanceof Expr\BinaryOp\SmallerOrEqual) {`
`323`		`- return $this->getType($expr->left, $context)->isSmallerThanOrEqual($this->getType($expr->right, $context))->toBooleanType();`
	`323`	`+ return $this->getType($expr->left, $context)->isSmallerThanOrEqual($this->getType($expr->right, $context), $this->phpVersion)->toBooleanType();`
`324`	`324`	`}`
`325`	`325`
`326`	`326`	`if ($expr instanceof Expr\BinaryOp\Greater) {`
`327`	`327`	`return $this->getType($expr->right, $context)->isSmallerThan($this->getType($expr->left, $context))->toBooleanType();`
`328`	`328`	`}`
`329`	`329`
`330`	`330`	`if ($expr instanceof Expr\BinaryOp\GreaterOrEqual) {`
`331`		`- return $this->getType($expr->right, $context)->isSmallerThanOrEqual($this->getType($expr->left, $context))->toBooleanType();`
	`331`	`+ return $this->getType($expr->right, $context)->isSmallerThanOrEqual($this->getType($expr->left, $context), $this->phpVersion)->toBooleanType();`
`332`	`332`	`}`
`333`	`333`
`334`	`334`	`if ($expr instanceof Expr\BinaryOp\LogicalXor) {`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace PHPStan\Type;`
`4`	`4`
	`5`	`+use PHPStan\Php\PhpVersion;`
`5`	`6`	`use PHPStan\TrinaryLogic;`
`6`	`7`
`7`	`8`	`/** @api */`
`@@ -16,6 +17,6 @@ public function isAcceptedWithReasonBy(Type $acceptingType, bool $strictTypes):`
`16`	`17`
`17`	`18`	`public function isGreaterThan(Type $otherType): TrinaryLogic;`
`18`	`19`
`19`		`- public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic;`
	`20`	`+ public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic;`
`20`	`21`
`21`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace PHPStan\Type\Enum;`
`4`	`4`
	`5`	`+use PHPStan\Php\PhpVersion;`
`5`	`6`	`use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;`
`6`	`7`	`use PHPStan\PhpDocParser\Ast\Type\ConstTypeNode;`
`7`	`8`	`use PHPStan\PhpDocParser\Ast\Type\TypeNode;`
`@@ -184,7 +185,7 @@ public function isSmallerThan(Type $otherType): TrinaryLogic`
`184`	`185`	`return TrinaryLogic::createNo();`
`185`	`186`	`}`
`186`	`187`
`187`		`- public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic`
	`188`	`+ public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`188`	`189`	`{`
`189`	`190`	`return TrinaryLogic::createNo();`
`190`	`191`	`}`
Original file line number	Diff line number	Diff line change
`@@ -325,18 +325,18 @@ public function isSmallerThan(Type $otherType): TrinaryLogic`
`325`	`325`	`return TrinaryLogic::extremeIdentity($minIsSmaller, $maxIsSmaller);`
`326`	`326`	`}`
`327`	`327`
`328`		`- public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic`
	`328`	`+ public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`329`	`329`	`{`
`330`	`330`	`if ($this->min === null) {`
`331`	`331`	`$minIsSmaller = TrinaryLogic::createYes();`
`332`	`332`	`} else {`
`333`		`- $minIsSmaller = (new ConstantIntegerType($this->min))->isSmallerThanOrEqual($otherType);`
	`333`	`+ $minIsSmaller = (new ConstantIntegerType($this->min))->isSmallerThanOrEqual($otherType, $phpVersion);`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`if ($this->max === null) {`
`337`	`337`	`$maxIsSmaller = TrinaryLogic::createNo();`
`338`	`338`	`} else {`
`339`		`- $maxIsSmaller = (new ConstantIntegerType($this->max))->isSmallerThanOrEqual($otherType);`
	`339`	`+ $maxIsSmaller = (new ConstantIntegerType($this->max))->isSmallerThanOrEqual($otherType, $phpVersion);`
`340`	`340`	`}`
`341`	`341`
`342`	`342`	`return TrinaryLogic::extremeIdentity($minIsSmaller, $maxIsSmaller);`
`@@ -359,18 +359,18 @@ public function isGreaterThan(Type $otherType): TrinaryLogic`
`359`	`359`	`return TrinaryLogic::extremeIdentity($minIsSmaller, $maxIsSmaller);`
`360`	`360`	`}`
`361`	`361`
`362`		`- public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic`
	`362`	`+ public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`363`	`363`	`{`
`364`	`364`	`if ($this->min === null) {`
`365`	`365`	`$minIsSmaller = TrinaryLogic::createNo();`
`366`	`366`	`} else {`
`367`		`- $minIsSmaller = $otherType->isSmallerThanOrEqual((new ConstantIntegerType($this->min)));`
	`367`	`+ $minIsSmaller = $otherType->isSmallerThanOrEqual((new ConstantIntegerType($this->min)), $phpVersion);`
`368`	`368`	`}`
`369`	`369`
`370`	`370`	`if ($this->max === null) {`
`371`	`371`	`$maxIsSmaller = TrinaryLogic::createYes();`
`372`	`372`	`} else {`
`373`		`- $maxIsSmaller = $otherType->isSmallerThanOrEqual((new ConstantIntegerType($this->max)));`
	`373`	`+ $maxIsSmaller = $otherType->isSmallerThanOrEqual((new ConstantIntegerType($this->max)), $phpVersion);`
`374`	`374`	`}`
`375`	`375`
`376`	`376`	`return TrinaryLogic::extremeIdentity($minIsSmaller, $maxIsSmaller);`
Original file line number	Diff line number	Diff line change
`@@ -807,9 +807,9 @@ public function isSmallerThan(Type $otherType): TrinaryLogic`
`807`	`807`	`return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThan($otherType));`
`808`	`808`	`}`
`809`	`809`
`810`		`- public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic`
	`810`	`+ public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`811`	`811`	`{`
`812`		`- return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThanOrEqual($otherType));`
	`812`	`+ return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isSmallerThanOrEqual($otherType, $phpVersion));`
`813`	`813`	`}`
`814`	`814`
`815`	`815`	`public function isNull(): TrinaryLogic`
`@@ -881,9 +881,9 @@ public function isGreaterThan(Type $otherType): TrinaryLogic`
`881`	`881`	`return $this->intersectResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThan($type));`
`882`	`882`	`}`
`883`	`883`
`884`		`- public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic`
	`884`	`+ public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`885`	`885`	`{`
`886`		`- return $this->intersectResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThanOrEqual($type));`
	`886`	`+ return $this->intersectResults(static fn (Type $type): TrinaryLogic => $otherType->isSmallerThanOrEqual($type, $phpVersion));`
`887`	`887`	`}`
`888`	`888`
`889`	`889`	`public function getSmallerType(): Type`
Original file line number	Diff line number	Diff line change
`@@ -121,14 +121,14 @@ public function isSmallerThan(Type $otherType): TrinaryLogic`
`121`	`121`	`return TrinaryLogic::createMaybe();`
`122`	`122`	`}`
`123`	`123`
`124`		`- public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic`
	`124`	`+ public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`125`	`125`	`{`
`126`	`126`	`if ($otherType instanceof ConstantScalarType) {`
`127`	`127`	`return TrinaryLogic::createFromBoolean(null <= $otherType->getValue());`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`if ($otherType instanceof CompoundType) {`
`131`		`- return $otherType->isGreaterThanOrEqual($this);`
	`131`	`+ return $otherType->isGreaterThanOrEqual($this, $phpVersion);`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`return TrinaryLogic::createMaybe();`
Original file line number	Diff line number	Diff line change
`@@ -91,14 +91,14 @@ public function isSmallerThan(Type $otherType): TrinaryLogic`
`91`	`91`	`return TrinaryLogic::createMaybe();`
`92`	`92`	`}`
`93`	`93`
`94`		`- public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic`
	`94`	`+ public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`95`	`95`	`{`
`96`	`96`	`if ($otherType instanceof ConstantScalarType) {`
`97`	`97`	`return TrinaryLogic::createFromBoolean($this->value <= $otherType->getValue());`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`if ($otherType instanceof CompoundType) {`
`101`		`- return $otherType->isGreaterThanOrEqual($this);`
	`101`	`+ return $otherType->isGreaterThanOrEqual($this, $phpVersion);`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`return TrinaryLogic::createMaybe();`
Original file line number	Diff line number	Diff line change
`@@ -372,9 +372,9 @@ public function isSmallerThan(Type $otherType): TrinaryLogic`
`372`	`372`	`return $this->resolve()->isSmallerThan($otherType);`
`373`	`373`	`}`
`374`	`374`
`375`		`- public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic`
	`375`	`+ public function isSmallerThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`376`	`376`	`{`
`377`		`- return $this->resolve()->isSmallerThanOrEqual($otherType);`
	`377`	`+ return $this->resolve()->isSmallerThanOrEqual($otherType, $phpVersion);`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`public function isNull(): TrinaryLogic`
`@@ -550,15 +550,15 @@ public function isGreaterThan(Type $otherType): TrinaryLogic`
`550`	`550`	`return $otherType->isSmallerThan($result);`
`551`	`551`	`}`
`552`	`552`
`553`		`- public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic`
	`553`	`+ public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`554`	`554`	`{`
`555`	`555`	`$result = $this->resolve();`
`556`	`556`
`557`	`557`	`if ($result instanceof CompoundType) {`
`558`		`- return $result->isGreaterThanOrEqual($otherType);`
	`558`	`+ return $result->isGreaterThanOrEqual($otherType, $phpVersion);`
`559`	`559`	`}`
`560`	`560`
`561`		`- return $otherType->isSmallerThanOrEqual($result);`
	`561`	`+ return $otherType->isSmallerThanOrEqual($result, $phpVersion);`
`562`	`562`	`}`
`563`	`563`
`564`	`564`	`public function exponentiate(Type $exponent): Type`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace PHPStan\Type\Traits;`
`4`	`4`
	`5`	`+use PHPStan\Php\PhpVersion;`
`5`	`6`	`use PHPStan\TrinaryLogic;`
`6`	`7`	`use PHPStan\Type\Type;`
`7`	`8`
`@@ -15,7 +16,7 @@ public function isGreaterThan(Type $otherType): TrinaryLogic`
`15`	`16`	`return TrinaryLogic::createMaybe();`
`16`	`17`	`}`
`17`	`18`
`18`		`- public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic`
	`19`	`+ public function isGreaterThanOrEqual(Type $otherType, PhpVersion $phpVersion): TrinaryLogic`
`19`	`20`	`{`
`20`	`21`	`return TrinaryLogic::createMaybe();`
`21`	`22`	`}`