Add NoArrayMapWithArrayCallableRule (#217)

Author: TomasVotruba

README.md

@@ -198,6 +198,35 @@ return __DIR__  . '/../fixtures/some_file.yml';
 :+1:
 
 
+<br>
+
+### NoArrayMapWithArrayCallableRule
+
+Array map with array callable is not allowed. Use anonymous/arrow function instead, to get better static analysis
+
+```yaml
+rules:
+    - Symplify\PHPStanRules\Rules\NoArrayMapWithArrayCallableRule
+```
+
+```php
+$items = ['apple', 'banana', 'orange'];
+$items = array_map(['SomeClass', 'method'], $items);
+```
+
+:x:
+
+<br>
+
+```php
+$items = ['apple', 'banana', 'orange'];
+$items = array_map(function ($item) {
+    return $this->method($item);
+}, $items);
+```
+
+:+1:
+
 <br>
 
 ### NoConstructorOverrideRule

composer.json

@@ -14,9 +14,9 @@
         "nikic/php-parser": "^5.4",
         "phpunit/phpunit": "^11.5",
         "symfony/framework-bundle": "6.1.*",
-        "phpecs/phpecs": "^2.0",
+        "phpecs/phpecs": "^2.1",
         "tomasvotruba/class-leak": "^2.0",
-        "rector/rector": "^2.0.10",
+        "rector/rector": "^2.0.11",
         "phpstan/extension-installer": "^1.4",
         "symplify/phpstan-extensions": "^12.0",
         "tomasvotruba/unused-public": "^2.0",

config/code-complexity-rules.neon

@@ -1,3 +1,4 @@
 rules:
     - Symplify\PHPStanRules\Rules\NoDynamicNameRule
     - Symplify\PHPStanRules\Rules\Complexity\NoJustPropertyAssignRule
+    - Symplify\PHPStanRules\Rules\Complexity\NoArrayMapWithArrayCallableRule

src/Enum/RuleIdentifier.php

@@ -73,4 +73,6 @@ final class RuleIdentifier
     public const NO_PROTECTED_CLASS_STMT = 'symplify.noProtectedClassStmt';
 
     public const CONVENTION_PARAM_NAME_TO_TYPE = 'symplify.conventionParamNameToType';
+
+    public const NO_ARRAY_MAP_WITH_ARRAY_CALLABLE = 'symplify.noArrayMapWithArrayCallable';
 }

src/Rules/Complexity/NoArrayMapWithArrayCallableRule.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Rules\Complexity;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\Expr\FuncCall;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
+use Symplify\PHPStanRules\Enum\RuleIdentifier;
+
+/**
+ * @implements Rule<FuncCall>
+ *
+ * @see \Symplify\PHPStanRules\Tests\Rules\NoArrayMapWithArrayCallableRule\NoArrayMapWithArrayCallableRuleTest
+ */
+final class NoArrayMapWithArrayCallableRule implements Rule
+{
+    /**
+     * @var string
+     */
+    public const ERROR_MESSAGE = 'Avoid using array callables in array_map(), as it cripples static analysis on used method';
+
+    public function getNodeType(): string
+    {
+        return FuncCall::class;
+    }
+
+    /**
+     * @param FuncCall $node
+     * @return RuleError[]
+     */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (! $node->name instanceof Name) {
+            return [];
+        }
+
+        $functionName = $node->name->toString();
+        if ($functionName !== 'array_map') {
+            return [];
+        }
+
+        if ($node->isFirstClassCallable()) {
+            return [];
+        }
+
+        $args = $node->getArgs();
+        $firstArgValue = $args[0]->value;
+        if (! $firstArgValue instanceof Array_) {
+            return [];
+        }
+
+        $identifierRuleError = RuleErrorBuilder::message(self::ERROR_MESSAGE)
+            ->identifier(RuleIdentifier::NO_ARRAY_MAP_WITH_ARRAY_CALLABLE)
+            ->build();
+
+        return [$identifierRuleError];
+    }
+}

tests/Rules/NoArrayMapWithArrayCallableRule/Fixture/SkipValidArrayMapCall.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\NoArrayMapWithArrayCallableRule\Fixture;
+
+final class SkipValidArrayMapCall
+{
+    public function run(array $items)
+    {
+        $changedItems = array_map(fn($item) => $this->change($item), $items);
+    }
+
+    public function change($item)
+    {
+        // ...
+    }
+}

tests/Rules/NoArrayMapWithArrayCallableRule/Fixture/SomeArrayMapCalls.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\NoArrayMapWithArrayCallableRule\Fixture;
+
+final class SomeArrayMapCalls
+{
+    public function run(array $items)
+    {
+        $changedItems = array_map([$this, 'change'], $items);
+    }
+
+    public function change()
+    {
+        // ...
+    }
+}

tests/Rules/NoArrayMapWithArrayCallableRule/NoArrayMapWithArrayCallableRuleTest.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\NoArrayMapWithArrayCallableRule;
+
+use Iterator;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Symplify\PHPStanRules\Rules\Complexity\NoArrayMapWithArrayCallableRule;
+
+final class NoArrayMapWithArrayCallableRuleTest extends RuleTestCase
+{
+    /**
+     * @param mixed[] $expectedErrorMessagesWithLines
+     */
+    #[DataProvider('provideData')]
+    public function testRule(string $filePath, array $expectedErrorMessagesWithLines): void
+    {
+        $this->analyse([$filePath], $expectedErrorMessagesWithLines);
+    }
+
+    public static function provideData(): Iterator
+    {
+        yield [
+            __DIR__ . '/Fixture/SomeArrayMapCalls.php',
+            [[NoArrayMapWithArrayCallableRule::ERROR_MESSAGE, 11]],
+        ];
+
+        yield [
+            __DIR__ . '/Fixture/SkipValidArrayMapCall.php',
+            [],
+        ];
+    }
+
+    /**
+     * @return string[]
+     */
+    public static function getAdditionalConfigFiles(): array
+    {
+        return [__DIR__ . '/config/configured_rule.neon'];
+    }
+
+    protected function getRule(): Rule
+    {
+        return self::getContainer()->getByType(NoArrayMapWithArrayCallableRule::class);
+    }
+}

tests/Rules/NoArrayMapWithArrayCallableRule/config/configured_rule.neon

@@ -0,0 +1,5 @@
+includes:
+    - ../../../config/included_services.neon
+
+rules:
+    - Symplify\PHPStanRules\Rules\Complexity\NoArrayMapWithArrayCallableRule