Arithmetic operators - respect levels more

ondrejmirtes · ondrejmirtes · commit 41f3063ed5bf · 2018-05-31T12:55:20.000+02:00
diff --git a/rules.neon b/rules.neon
@@ -27,3 +27,7 @@ rules:
 	- PHPStan\Rules\StrictCalls\DynamicCallOnStaticMethodsRule
 	- PHPStan\Rules\StrictCalls\StrictFunctionCallsRule
 	- PHPStan\Rules\SwitchConditions\MatchingTypeInSwitchCaseConditionRule
+
+services:
+	-
+		class: PHPStan\Rules\Operators\OperatorRuleHelper
diff --git a/src/Rules/Operators/OperandsInArithmeticAdditionRule.php b/src/Rules/Operators/OperandsInArithmeticAdditionRule.php
@@ -9,6 +9,14 @@
 class OperandsInArithmeticAdditionRule implements \PHPStan\Rules\Rule
 {
 
+	/** @var OperatorRuleHelper */
+	private $helper;
+
+	public function __construct(OperatorRuleHelper $helper)
+	{
+		$this->helper = $helper;
+	}
+
 	public function getNodeType(): string
 	{
 		return \PhpParser\Node\Expr\BinaryOp\Plus::class;
@@ -30,13 +38,13 @@ public function processNode(\PhpParser\Node $node, \PHPStan\Analyser\Scope $scop
 		}
 
 		$messages = [];
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($leftType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->left)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in +, %s given on the left side.',
 				$leftType->describe(VerbosityLevel::typeOnly())
 			);
 		}
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($rightType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->right)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in +, %s given on the right side.',
 				$rightType->describe(VerbosityLevel::typeOnly())
diff --git a/src/Rules/Operators/OperandsInArithmeticDivisionRule.php b/src/Rules/Operators/OperandsInArithmeticDivisionRule.php
@@ -7,6 +7,14 @@
 class OperandsInArithmeticDivisionRule implements \PHPStan\Rules\Rule
 {
 
+	/** @var OperatorRuleHelper */
+	private $helper;
+
+	public function __construct(OperatorRuleHelper $helper)
+	{
+		$this->helper = $helper;
+	}
+
 	public function getNodeType(): string
 	{
 		return \PhpParser\Node\Expr\BinaryOp\Div::class;
@@ -21,15 +29,15 @@ public function processNode(\PhpParser\Node $node, \PHPStan\Analyser\Scope $scop
 	{
 		$messages = [];
 		$leftType = $scope->getType($node->left);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($leftType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->left)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in /, %s given on the left side.',
 				$leftType->describe(VerbosityLevel::typeOnly())
 			);
 		}
 
 		$rightType = $scope->getType($node->right);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($rightType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->right)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in /, %s given on the right side.',
 				$rightType->describe(VerbosityLevel::typeOnly())
diff --git a/src/Rules/Operators/OperandsInArithmeticExponentiationRule.php b/src/Rules/Operators/OperandsInArithmeticExponentiationRule.php
@@ -7,6 +7,14 @@
 class OperandsInArithmeticExponentiationRule implements \PHPStan\Rules\Rule
 {
 
+	/** @var OperatorRuleHelper */
+	private $helper;
+
+	public function __construct(OperatorRuleHelper $helper)
+	{
+		$this->helper = $helper;
+	}
+
 	public function getNodeType(): string
 	{
 		return \PhpParser\Node\Expr\BinaryOp\Pow::class;
@@ -21,15 +29,15 @@ public function processNode(\PhpParser\Node $node, \PHPStan\Analyser\Scope $scop
 	{
 		$messages = [];
 		$leftType = $scope->getType($node->left);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($leftType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->left)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in **, %s given on the left side.',
 				$leftType->describe(VerbosityLevel::typeOnly())
 			);
 		}
 
 		$rightType = $scope->getType($node->right);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($rightType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->right)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in **, %s given on the right side.',
 				$rightType->describe(VerbosityLevel::typeOnly())
diff --git a/src/Rules/Operators/OperandsInArithmeticModuloRule.php b/src/Rules/Operators/OperandsInArithmeticModuloRule.php
@@ -7,6 +7,14 @@
 class OperandsInArithmeticModuloRule implements \PHPStan\Rules\Rule
 {
 
+	/** @var OperatorRuleHelper */
+	private $helper;
+
+	public function __construct(OperatorRuleHelper $helper)
+	{
+		$this->helper = $helper;
+	}
+
 	public function getNodeType(): string
 	{
 		return \PhpParser\Node\Expr\BinaryOp\Mod::class;
@@ -21,15 +29,15 @@ public function processNode(\PhpParser\Node $node, \PHPStan\Analyser\Scope $scop
 	{
 		$messages = [];
 		$leftType = $scope->getType($node->left);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($leftType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->left)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in %%, %s given on the left side.',
 				$leftType->describe(VerbosityLevel::typeOnly())
 			);
 		}
 
 		$rightType = $scope->getType($node->right);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($rightType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->right)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in %%, %s given on the right side.',
 				$rightType->describe(VerbosityLevel::typeOnly())
diff --git a/src/Rules/Operators/OperandsInArithmeticMultiplicationRule.php b/src/Rules/Operators/OperandsInArithmeticMultiplicationRule.php
@@ -7,6 +7,14 @@
 class OperandsInArithmeticMultiplicationRule implements \PHPStan\Rules\Rule
 {
 
+	/** @var OperatorRuleHelper */
+	private $helper;
+
+	public function __construct(OperatorRuleHelper $helper)
+	{
+		$this->helper = $helper;
+	}
+
 	public function getNodeType(): string
 	{
 		return \PhpParser\Node\Expr\BinaryOp\Mul::class;
@@ -21,15 +29,15 @@ public function processNode(\PhpParser\Node $node, \PHPStan\Analyser\Scope $scop
 	{
 		$messages = [];
 		$leftType = $scope->getType($node->left);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($leftType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->left)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in *, %s given on the left side.',
 				$leftType->describe(VerbosityLevel::typeOnly())
 			);
 		}
 
 		$rightType = $scope->getType($node->right);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($rightType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->right)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in *, %s given on the right side.',
 				$rightType->describe(VerbosityLevel::typeOnly())
diff --git a/src/Rules/Operators/OperandsInArithmeticSubtractionRule.php b/src/Rules/Operators/OperandsInArithmeticSubtractionRule.php
@@ -7,6 +7,14 @@
 class OperandsInArithmeticSubtractionRule implements \PHPStan\Rules\Rule
 {
 
+	/** @var OperatorRuleHelper */
+	private $helper;
+
+	public function __construct(OperatorRuleHelper $helper)
+	{
+		$this->helper = $helper;
+	}
+
 	public function getNodeType(): string
 	{
 		return \PhpParser\Node\Expr\BinaryOp\Minus::class;
@@ -21,15 +29,15 @@ public function processNode(\PhpParser\Node $node, \PHPStan\Analyser\Scope $scop
 	{
 		$messages = [];
 		$leftType = $scope->getType($node->left);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($leftType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->left)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in -, %s given on the left side.',
 				$leftType->describe(VerbosityLevel::typeOnly())
 			);
 		}
 
 		$rightType = $scope->getType($node->right);
-		if (!OperatorRuleHelper::isValidForArithmeticOperation($rightType)) {
+		if (!$this->helper->isValidForArithmeticOperation($scope, $node->right)) {
 			$messages[] = sprintf(
 				'Only numeric types are allowed in -, %s given on the right side.',
 				$rightType->describe(VerbosityLevel::typeOnly())
diff --git a/src/Rules/Operators/OperatorRuleHelper.php b/src/Rules/Operators/OperatorRuleHelper.php
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Rules\Operators;
 
+use PhpParser\Node\Expr;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\FloatType;
 use PHPStan\Type\IntegerType;
@@ -12,8 +15,17 @@
 class OperatorRuleHelper
 {
 
-	public static function isValidForArithmeticOperation(Type $type): bool
+	/** @var \PHPStan\Rules\RuleLevelHelper */
+	private $ruleLevelHelper;
+
+	public function __construct(RuleLevelHelper $ruleLevelHelper)
+	{
+		$this->ruleLevelHelper = $ruleLevelHelper;
+	}
+
+	public function isValidForArithmeticOperation(Scope $scope, Expr $expr): bool
 	{
+		$type = $scope->getType($expr);
 		if ($type instanceof MixedType) {
 			return true;
 		}
@@ -24,6 +36,19 @@ public static function isValidForArithmeticOperation(Type $type): bool
 
 		$acceptedType = new UnionType([new IntegerType(), new FloatType()]);
 
+		$typeToCheck = $this->ruleLevelHelper->findTypeToCheck(
+			$scope,
+			$expr,
+			'',
+			function (Type $type) use ($acceptedType): bool {
+				return $acceptedType->isSuperTypeOf($type)->yes();
+			}
+		);
+		$type = $typeToCheck->getType();
+		if ($type instanceof ErrorType) {
+			return true;
+		}
+
 		return $acceptedType->isSuperTypeOf($type)->yes();
 	}
 
diff --git a/tests/Levels/data/arithmeticOperators-0.json b/tests/Levels/data/arithmeticOperators-0.json
diff --git a/tests/Levels/data/arithmeticOperators-2.json b/tests/Levels/data/arithmeticOperators-2.json
@@ -4,9 +4,19 @@
         "line": 26,
         "ignorable": true
     },
+    {
+        "message": "Only numeric types are allowed in +, string given on the left side.",
+        "line": 27,
+        "ignorable": true
+    },
     {
         "message": "Binary operation \"+\" between stdClass|string and int results in an error.",
         "line": 36,
         "ignorable": true
+    },
+    {
+        "message": "Only numeric types are allowed in +, string given on the left side.",
+        "line": 43,
+        "ignorable": true
     }
 ]
diff --git a/tests/Levels/data/arithmeticOperators-6.json b/tests/Levels/data/arithmeticOperators-6.json
@@ -3,5 +3,10 @@
         "message": "Binary operation \"+\" between int|string and int results in an error.",
         "line": 28,
         "ignorable": true
+    },
+    {
+        "message": "Only numeric types are allowed in +, int|string given on the left side.",
+        "line": 29,
+        "ignorable": true
     }
 ]
diff --git a/tests/Rules/Operators/OperandsInArithmeticAdditionRuleTest.php b/tests/Rules/Operators/OperandsInArithmeticAdditionRuleTest.php
@@ -3,13 +3,18 @@
 namespace PHPStan\Rules\Operators;
 
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleLevelHelper;
 
 class OperandsInArithmeticAdditionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
 	protected function getRule(): Rule
 	{
-		return new OperandsInArithmeticAdditionRule();
+		return new OperandsInArithmeticAdditionRule(
+			new OperatorRuleHelper(
+				new RuleLevelHelper($this->createBroker(), true, false, true)
+			)
+		);
 	}
 
 	public function testRule(): void
diff --git a/tests/Rules/Operators/OperandsInArithmeticDivisionRuleTest.php b/tests/Rules/Operators/OperandsInArithmeticDivisionRuleTest.php
@@ -3,13 +3,18 @@
 namespace PHPStan\Rules\Operators;
 
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleLevelHelper;
 
 class OperandsInArithmeticDivisionRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
 	protected function getRule(): Rule
 	{
-		return new OperandsInArithmeticDivisionRule();
+		return new OperandsInArithmeticDivisionRule(
+			new OperatorRuleHelper(
+				new RuleLevelHelper($this->createBroker(), true, false, true)
+			)
+		);
 	}
 
 	public function testRule(): void
diff --git a/tests/Rules/Operators/OperandsInArithmeticExponentiationRuleTest.php b/tests/Rules/Operators/OperandsInArithmeticExponentiationRuleTest.php
@@ -3,13 +3,18 @@
 namespace PHPStan\Rules\Operators;
 
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleLevelHelper;
 
 class OperandsInArithmeticExponentiationRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
 	protected function getRule(): Rule
 	{
-		return new OperandsInArithmeticExponentiationRule();
+		return new OperandsInArithmeticExponentiationRule(
+			new OperatorRuleHelper(
+				new RuleLevelHelper($this->createBroker(), true, false, true)
+			)
+		);
 	}
 
 	public function testRule(): void
diff --git a/tests/Rules/Operators/OperandsInArithmeticModuloRuleTest.php b/tests/Rules/Operators/OperandsInArithmeticModuloRuleTest.php
@@ -3,13 +3,18 @@
 namespace PHPStan\Rules\Operators;
 
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleLevelHelper;
 
 class OperandsInArithmeticModuloRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
 	protected function getRule(): Rule
 	{
-		return new OperandsInArithmeticModuloRule();
+		return new OperandsInArithmeticModuloRule(
+			new OperatorRuleHelper(
+				new RuleLevelHelper($this->createBroker(), true, false, true)
+			)
+		);
 	}
 
 	public function testRule(): void
diff --git a/tests/Rules/Operators/OperandsInArithmeticMultiplicationRuleTest.php b/tests/Rules/Operators/OperandsInArithmeticMultiplicationRuleTest.php
diff --git a/tests/Rules/Operators/OperandsInArithmeticSubtractionRuleTest.php b/tests/Rules/Operators/OperandsInArithmeticSubtractionRuleTest.php

Original file line number	Diff line number	Diff line change
`@@ -3,5 +3,10 @@`
`3`	`3`	`"message": "Binary operation \"+\" between int\|string and int results in an error.",`
`4`	`4`	`"line": 28,`
`5`	`5`	`"ignorable": true`
	`6`	`+ },`
	`7`	`+ {`
	`8`	`+ "message": "Only numeric types are allowed in +, int\|string given on the left side.",`
	`9`	`+ "line": 29,`
	`10`	`+ "ignorable": true`
`6`	`11`	`}`
`7`	`12`	`]`
Original file line number	Diff line number	Diff line change
`@@ -3,13 +3,18 @@`
`3`	`3`	`namespace PHPStan\Rules\Operators;`
`4`	`4`
`5`	`5`	`use PHPStan\Rules\Rule;`
	`6`	`+use PHPStan\Rules\RuleLevelHelper;`
`6`	`7`
`7`	`8`	`class OperandsInArithmeticAdditionRuleTest extends \PHPStan\Testing\RuleTestCase`
`8`	`9`	`{`
`9`	`10`
`10`	`11`	`protected function getRule(): Rule`
`11`	`12`	`{`
`12`		`- return new OperandsInArithmeticAdditionRule();`
	`13`	`+ return new OperandsInArithmeticAdditionRule(`
	`14`	`+ new OperatorRuleHelper(`
	`15`	`+ new RuleLevelHelper($this->createBroker(), true, false, true)`
	`16`	`+ )`
	`17`	`+ );`
`13`	`18`	`}`
`14`	`19`
`15`	`20`	`public function testRule(): void`