Merge pull request #32 from mll-lab/handle-potential-first-class-callable

Handle FuncCall nodes that represent first class callables

Author: shish

phpstan-safe-rule.neon

@@ -1,4 +1,8 @@
 services:
+  -
+    class: TheCodingMachine\Safe\PHPStan\Rules\UseSafeCallablesRule
+    tags:
+      - phpstan.rules.rule
   -
     class: TheCodingMachine\Safe\PHPStan\Rules\UseSafeFunctionsRule
     tags:

phpstan.neon

@@ -4,7 +4,9 @@ parameters:
         - src
         - tests
     excludePaths:
-        - tests/Rules/data
+        - tests/Rules/UseSafeCallablesRule
+        - tests/Rules/UseSafeClassesRule
+        - tests/Rules/UseSafeFunctionsRule
     ignoreErrors:
         -
             message: '#^Implementing PHPStan\\Rules\\IdentifierRuleError is not covered by backward compatibility promise\. The interface might change in a minor PHPStan version\.$#'

src/Rules/UseSafeCallablesRule.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace TheCodingMachine\Safe\PHPStan\Rules;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Node\FunctionCallableNode;
+use TheCodingMachine\Safe\PHPStan\Rules\Error\SafeFunctionRuleError;
+use TheCodingMachine\Safe\PHPStan\Utils\FunctionListLoader;
+
+/**
+ * This rule checks that no "unsafe" functions are used in code.
+ *
+ * @implements Rule<FunctionCallableNode>
+ */
+class UseSafeCallablesRule implements Rule
+{
+    /**
+     * @see JSON_THROW_ON_ERROR
+     */
+    const JSON_THROW_ON_ERROR = 4194304;
+
+    public function getNodeType(): string
+    {
+        return FunctionCallableNode::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        $nodeName = $node->getName();
+        if (!$nodeName instanceof Node\Name) {
+            return [];
+        }
+        $functionName = $nodeName->toString();
+        $unsafeFunctions = FunctionListLoader::getFunctionList();
+
+        if (isset($unsafeFunctions[$functionName])) {
+            return [new SafeFunctionRuleError($nodeName, $node->getStartLine())];
+        }
+
+        return [];
+    }
+}

src/Rules/UseSafeFunctionsRule.php

@@ -1,6 +1,5 @@
 <?php
 
-
 namespace TheCodingMachine\Safe\PHPStan\Rules;
 
 use PhpParser\Node;
@@ -19,17 +18,23 @@
  */
 class UseSafeFunctionsRule implements Rule
 {
+    /**
+     * @see JSON_THROW_ON_ERROR
+     */
+    const JSON_THROW_ON_ERROR = 4194304;
+
     public function getNodeType(): string
     {
         return Node\Expr\FuncCall::class;
     }
 
     public function processNode(Node $node, Scope $scope): array
     {
-        if (!$node->name instanceof Node\Name) {
+        $nodeName = $node->name;
+        if (!$nodeName instanceof Node\Name) {
             return [];
         }
-        $functionName = $node->name->toString();
+        $functionName = $nodeName->toString();
         $unsafeFunctions = FunctionListLoader::getFunctionList();
 
         if (isset($unsafeFunctions[$functionName])) {
@@ -58,7 +63,7 @@ public function processNode(Node $node, Scope $scope): array
                 return [];
             }
 
-            return [new SafeFunctionRuleError($node->name, $node->getStartLine())];
+            return [new SafeFunctionRuleError($nodeName, $node->getStartLine())];
         }
 
         return [];
@@ -87,11 +92,16 @@ private function argValueIncludeJSONTHROWONERROR(?Arg $arg): bool
             return true;
         }
 
-        return in_array(true, array_map(function ($element) {
-            // JSON_THROW_ON_ERROR == 4194304
-            return ($element & 4194304) == 4194304;
-        }, array_filter($options, function ($element) {
-            return is_int($element);
-        })), true);
+        $intOptions = array_filter($options, function (mixed $option): bool {
+            return is_int($option);
+        });
+
+        foreach ($intOptions as $option) {
+            if (($option & self::JSON_THROW_ON_ERROR) === self::JSON_THROW_ON_ERROR) {
+                return true;
+            }
+        }
+
+        return false;
     }
 }

src/Type/Php/ReplaceSafeFunctionsDynamicReturnTypeExtension.php

@@ -56,22 +56,17 @@ private function getPreliminarilyResolvedTypeFromFunctionCall(
         Scope $scope
     ): Type {
         $argumentPosition = $this->functions[$functionReflection->getName()];
-        $defaultReturnType = ParametersAcceptorSelector::selectFromArgs(
-            $scope,
-            $functionCall->getArgs(),
-            $functionReflection->getVariants()
-        )
+
+        $args = $functionCall->getArgs();
+        $variants = $functionReflection->getVariants();
+        $defaultReturnType = ParametersAcceptorSelector::selectFromArgs($scope, $args, $variants)
             ->getReturnType();
-        
-        if (count($functionCall->args) <= $argumentPosition) {
-            return $defaultReturnType;
-        }
 
-        $subjectArgument = $functionCall->args[$argumentPosition];
-        if (!$subjectArgument instanceof Arg) {
+        if (count($args) <= $argumentPosition) {
             return $defaultReturnType;
         }
-        
+
+        $subjectArgument = $args[$argumentPosition];
         $subjectArgumentType = $scope->getType($subjectArgument->value);
         $mixedType = new MixedType();
         if ($subjectArgumentType->isSuperTypeOf($mixedType)->yes()) {

tests/Rules/UseSafeCallablesRule/expr.php

@@ -0,0 +1,4 @@
+<?php
+
+$json_encode_name = 'json_encode';
+$encode_from_expression = $json_encode_name(...);

tests/Rules/UseSafeCallablesRule/native_safe.php

@@ -0,0 +1,3 @@
+<?php
+
+var_dump(...);

tests/Rules/UseSafeCallablesRule/unsafe.php

@@ -0,0 +1,3 @@
+<?php
+
+json_encode(...);

tests/Rules/UseSafeCallablesRule/use_safe.php

@@ -0,0 +1,5 @@
+<?php
+
+use function Safe\json_encode;
+
+json_encode(...);

tests/Rules/UseSafeCallablesRuleTest.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace TheCodingMachine\Safe\PHPStan\Rules;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @template-extends RuleTestCase<UseSafeCallablesRule>
+ */
+class UseSafeCallablesRuleTest extends RuleTestCase
+{
+    protected function getRule(): Rule
+    {
+        return new UseSafeCallablesRule();
+    }
+
+    public function testUnsafe(): void
+    {
+        $this->analyse([__DIR__ . '/UseSafeCallablesRule/unsafe.php'], [
+            [
+                "Function json_encode is unsafe to use. It can return FALSE instead of throwing an exception. Please add 'use function Safe\\json_encode;' at the beginning of the file to use the variant provided by the 'thecodingmachine/safe' library.",
+                3,
+            ],
+        ]);
+    }
+
+    public function testUseSafe(): void
+    {
+        $this->analyse([__DIR__ . '/UseSafeCallablesRule/use_safe.php'], []);
+    }
+
+    public function testNativeSafe(): void
+    {
+        $this->analyse([__DIR__ . '/UseSafeCallablesRule/native_safe.php'], []);
+    }
+
+    public function testExpr(): void
+    {
+        $this->analyse([__DIR__ . '/UseSafeCallablesRule/expr.php'], []);
+    }
+}