Merge pull request #18 from lookyman/phpstan-0.12

Bump PHPStan dependency to 0.12
Roave · Jan 28, 2020 · 00cd927 · 00cd927
2 parents f0bfc94 + 497505e
commit 00cd927
Show file tree

Hide file tree

Showing 13 changed files with 73 additions and 56 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -35,9 +35,3 @@ jobs:
 
     - stage: Code Style
       script: vendor/bin/phpcs
-
-    - stage: Dependencies Check
-      script: vendor/bin/composer-require-checker
-
-    - stage: Backwards Compatibility Check
-      script: vendor/bin/roave-backward-compatibility-check
diff --git a/composer.json b/composer.json
@@ -7,16 +7,14 @@
     "require": {
         "php": "^7.2",
         "nikic/php-parser": "^4.0",
-        "phpstan/phpstan": "^0.11.7"
+        "phpstan/phpstan": "^0.12"
     },
     "require-dev": {
         "doctrine/coding-standard": "^6.0",
         "infection/infection": "^0.11.4",
-        "maglnet/composer-require-checker": "^1.1",
-        "phpstan/phpstan-phpunit": "^0.11",
-        "phpstan/phpstan-strict-rules": "^0.11",
+        "phpstan/phpstan-phpunit": "^0.12",
+        "phpstan/phpstan-strict-rules": "^0.12",
         "phpunit/phpunit": "^7.4",
-        "roave/backward-compatibility-check": "^2.0",
         "squizlabs/php_codesniffer": "^3.4"
     },
     "autoload": {

diff --git a/phpstan.neon.dist b/phpstan.neon.dist
@@ -8,7 +8,7 @@ parameters:
 	paths:
 		- %currentWorkingDirectory%/src
 		- %currentWorkingDirectory%/tests/src
-	level: 7
+	level: 8
 
 services:
 	scopeIsInClass:

diff --git a/src/DisallowFloatAssignedToVariableRule.php b/src/DisallowFloatAssignedToVariableRule.php
@@ -8,9 +8,13 @@
 use PhpParser\PrettyPrinter\Standard;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\VerbosityLevel;
 use function sprintf;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node>
+ */
 final class DisallowFloatAssignedToVariableRule implements Rule
 {
     /** @var Standard */
@@ -27,7 +31,7 @@ public function getNodeType() : string
     }
 
     /**
-     * @return string[]
+     * {@inheritDoc}
      */
     public function processNode(Node $node, Scope $scope) : array
     {
@@ -41,11 +45,11 @@ public function processNode(Node $node, Scope $scope) : array
         }
 
         return [
-            sprintf(
+            RuleErrorBuilder::message(sprintf(
                 'Cannot assign %s to %s - floats are not allowed.',
                 $resultType->describe(VerbosityLevel::typeOnly()),
                 $this->printer->prettyPrintExpr($node->var)
-            ),
+            ))->build(),
         ];
     }
 }
diff --git a/src/DisallowFloatEverywhereRule.php b/src/DisallowFloatEverywhereRule.php
@@ -8,10 +8,13 @@
 use PhpParser\Node\Expr;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\VerbosityLevel;
-use function assert;
 use function sprintf;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr>
+ */
 class DisallowFloatEverywhereRule implements Rule
 {
     public function getNodeType() : string
@@ -20,7 +23,7 @@ public function getNodeType() : string
     }
 
     /**
-     * @return string[]
+     * {@inheritDoc}
      */
     public function processNode(Node $node, Scope $scope) : array
     {
@@ -30,18 +33,16 @@ public function processNode(Node $node, Scope $scope) : array
             return [];
         }
 
-        assert($node instanceof Expr);
-
         $nodeType = $scope->getType($node);
         if (! FloatTypeHelper::isFloat($nodeType)) {
             return [];
         }
 
         return [
-            sprintf(
+            RuleErrorBuilder::message(sprintf(
                 'Cannot have %s as a result type of this expression - floats are not allowed.',
                 $nodeType->describe(VerbosityLevel::typeOnly())
-            ),
+            ))->build(),
         ];
     }
 }
diff --git a/src/DisallowFloatInFunctionSignatureRule.php b/src/DisallowFloatInFunctionSignatureRule.php
@@ -11,17 +11,21 @@
 use PHPStan\Broker\Broker;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\ParameterReflection;
-use PHPStan\Reflection\ParametersAcceptorWithPhpDocs;
+use PHPStan\Reflection\ParametersAcceptor;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\VerbosityLevel;
 use function array_filter;
 use function array_keys;
 use function array_map;
 use function array_merge;
 use function array_values;
-use function assert;
 use function sprintf;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Function_>
+ */
 final class DisallowFloatInFunctionSignatureRule implements Rule
 {
     /** @var Broker */
@@ -38,18 +42,16 @@ public function getNodeType() : string
     }
 
     /**
-     * @return string[]
+     * {@inheritDoc}
      */
     public function processNode(Node $node, Scope $scope) : array
     {
-        assert($node instanceof Function_);
-
         $functionName = new Name($node->name->toString());
-        if (! $this->broker->hasCustomFunction($functionName, $scope)) {
+        if (! $this->broker->hasFunction($functionName, $scope)) {
             return [];
         }
 
-        $functionReflection = $this->broker->getCustomFunction($functionName, $scope);
+        $functionReflection = $this->broker->getFunction($functionName, $scope);
 
         $errors = [];
 
@@ -61,43 +63,43 @@ public function processNode(Node $node, Scope $scope) : array
         return array_filter(array_merge([], ...$errors));
     }
 
-    /** @return string[] */
+    /** @return RuleError[] */
     private function returnTypeViolations(
-        ParametersAcceptorWithPhpDocs $function,
+        ParametersAcceptor $function,
         FunctionReflection $functionReflection
     ) : array {
         if (! FloatTypeHelper::isFloat($function->getReturnType())) {
             return [];
         }
 
-        return [sprintf(
+        return [RuleErrorBuilder::message(sprintf(
             'Function %s() cannot have %s as its return type - floats are not allowed.',
             $functionReflection->getName(),
             $function->getReturnType()->describe(VerbosityLevel::typeOnly())
-        ),
+        ))->build(),
         ];
     }
 
-    /** @return string[]|null[] */
+    /** @return RuleError[]|null[] */
     private function violationsForParameters(
-        ParametersAcceptorWithPhpDocs $function,
+        ParametersAcceptor $function,
         FunctionReflection $functionReflection
     ) : array {
         $parameters = $function->getParameters();
 
         return array_map(
-            static function (ParameterReflection $parameter, int $index) use ($functionReflection) : ?string {
+            static function (ParameterReflection $parameter, int $index) use ($functionReflection) : ?RuleError {
                 if (! FloatTypeHelper::isFloat($parameter->getType())) {
                     return null;
                 }
 
-                return sprintf(
+                return RuleErrorBuilder::message(sprintf(
                     'Parameter #%d $%s of function %s() cannot have %s as its type - floats are not allowed.',
                     $index + 1,
                     $parameter->getName(),
                     $functionReflection->getName(),
                     $parameter->getType()->describe(VerbosityLevel::typeOnly())
-                );
+                ))->build();
             },
             array_values($parameters),
             array_keys($parameters)

diff --git a/src/DisallowFloatInMethodSignatureRule.php b/src/DisallowFloatInMethodSignatureRule.php
@@ -11,16 +11,20 @@
 use PHPStan\Reflection\ParameterReflection;
 use PHPStan\Reflection\ParametersAcceptor;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\VerbosityLevel;
 use function array_filter;
 use function array_keys;
 use function array_map;
 use function array_merge;
 use function array_values;
-use function assert;
 use function sprintf;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\ClassMethod>
+ */
 final class DisallowFloatInMethodSignatureRule implements Rule
 {
     public function getNodeType() : string
@@ -29,12 +33,10 @@ public function getNodeType() : string
     }
 
     /**
-     * @return string[]
+     * {@inheritDoc}
      */
     public function processNode(Node $node, Scope $scope) : array
     {
-        assert($node instanceof ClassMethod);
-
         if (! $scope->isInClass()) {
             throw new ShouldNotHappenException();
         }
@@ -53,7 +55,7 @@ public function processNode(Node $node, Scope $scope) : array
         return array_filter(array_merge([], ...$errors));
     }
 
-    /** @return string[] */
+    /** @return RuleError[] */
     private function returnTypeViolations(
         ParametersAcceptor $method,
         MethodReflection $methodReflection
@@ -62,36 +64,36 @@ private function returnTypeViolations(
             return [];
         }
 
-        return [sprintf(
+        return [RuleErrorBuilder::message(sprintf(
             'Method %s::%s() cannot have %s as its return type - floats are not allowed.',
             $methodReflection->getDeclaringClass()->getDisplayName(),
             $methodReflection->getName(),
             $method->getReturnType()->describe(VerbosityLevel::typeOnly())
-        ),
+        ))->build(),
         ];
     }
 
-    /** @return string[]|null[] */
+    /** @return RuleError[]|null[] */
     private function violationsForParameters(
         ParametersAcceptor $function,
         MethodReflection $methodReflection
     ) : array {
         $parameters = $function->getParameters();
 
         return array_map(
-            static function (ParameterReflection $parameter, int $index) use ($methodReflection) : ?string {
+            static function (ParameterReflection $parameter, int $index) use ($methodReflection) : ?RuleError {
                 if (! FloatTypeHelper::isFloat($parameter->getType())) {
                     return null;
                 }
 
-                return sprintf(
+                return RuleErrorBuilder::message(sprintf(
                     'Parameter #%d $%s of method %s::%s() cannot have %s as its type - floats are not allowed.',
                     $index + 1,
                     $parameter->getName(),
                     $methodReflection->getDeclaringClass()->getDisplayName(),
                     $methodReflection->getName(),
                     $parameter->getType()->describe(VerbosityLevel::typeOnly())
-                );
+                ))->build();
             },
             array_values($parameters),
             array_keys($parameters)

diff --git a/src/DisallowFloatPropertyTypeRule.php b/src/DisallowFloatPropertyTypeRule.php
@@ -8,11 +8,14 @@
 use PhpParser\Node\Stmt\PropertyProperty;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\VerbosityLevel;
-use function assert;
 use function sprintf;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\PropertyProperty>
+ */
 final class DisallowFloatPropertyTypeRule implements Rule
 {
     public function getNodeType() : string
@@ -21,31 +24,29 @@ public function getNodeType() : string
     }
 
     /**
-     * @return string[]
+     * {@inheritDoc}
      */
     public function processNode(Node $node, Scope $scope) : array
     {
-        assert($node instanceof PropertyProperty);
-
         if (! $scope->isInClass()) {
             throw new ShouldNotHappenException();
         }
 
         $classReflection = $scope->getClassReflection();
         $propertyName    = $node->name->toString();
         $property        = $classReflection->getNativeProperty($node->name->toString());
-        $propertyType    = $property->getType();
+        $propertyType    = $property->getReadableType();
         if (! FloatTypeHelper::isFloat($propertyType)) {
             return [];
         }
 
         return [
-            sprintf(
+            RuleErrorBuilder::message(sprintf(
                 'Property %s::$%s cannot have %s as its type - floats are not allowed.',
                 $property->getDeclaringClass()->getDisplayName(),
                 $propertyName,
                 $propertyType->describe(VerbosityLevel::typeOnly())
-            ),
+            ))->build(),
         ];
     }
 }
diff --git a/tests/src/DisallowFloatAssignedToVariableRuleTest.php b/tests/src/DisallowFloatAssignedToVariableRuleTest.php
@@ -9,6 +9,9 @@
 use PHPStan\Testing\RuleTestCase;
 use Roave\PHPStan\Rules\Floats\DisallowFloatAssignedToVariableRule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<\Roave\PHPStan\Rules\Floats\DisallowFloatAssignedToVariableRule>
+ */
 final class DisallowFloatAssignedToVariableRuleTest extends RuleTestCase
 {
     protected function getRule() : Rule

diff --git a/tests/src/DisallowFloatEverywhereRuleTest.php b/tests/src/DisallowFloatEverywhereRuleTest.php
@@ -8,6 +8,9 @@
 use PHPStan\Testing\RuleTestCase;
 use Roave\PHPStan\Rules\Floats\DisallowFloatEverywhereRule;
 
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<\Roave\PHPStan\Rules\Floats\DisallowFloatEverywhereRule>
+ */
 class DisallowFloatEverywhereRuleTest extends RuleTestCase
 {
     protected function getRule() : Rule

diff --git a/...allowFloatinFunctionSignatureRuleTest.php → ...allowFloatInFunctionSignatureRuleTest.php b/...allowFloatinFunctionSignatureRuleTest.php → ...allowFloatInFunctionSignatureRuleTest.php
@@ -8,7 +8,10 @@
 use PHPStan\Testing\RuleTestCase;
 use Roave\PHPStan\Rules\Floats\DisallowFloatInFunctionSignatureRule;
 
-final class DisallowFloatinFunctionSignatureRuleTest extends RuleTestCase
+/**
+ * @extends \PHPStan\Testing\RuleTestCase<\Roave\PHPStan\Rules\Floats\DisallowFloatInFunctionSignatureRule>
+ */
+final class DisallowFloatInFunctionSignatureRuleTest extends RuleTestCase
 {
     protected function getRule() : Rule
     {