Add NoClassConstFetchOnFactoriesFunctions

Author: paulbalandan

README.md

@@ -24,6 +24,7 @@ This extension provides the following features:
 * Disallows instantiating cache handlers using `new` and suggests to use the `CacheFactory` class instead.
 * Disallows instantiating `FrameworkException` classes using `new`.
 * Disallows direct re-assignment or access of `$_SERVER` and `$_GET` and suggests to use the `Superglobals` class instead.
+* Disallows use of `::class` fetch on `config()` and `model()` and suggests to use the short form of the class instead.
 
 ## Installation
 

extension.neon

@@ -88,5 +88,6 @@ conditionalTags:
 rules:
   - CodeIgniter\PHPStan\Rules\Classes\CacheHandlerInstantiationRule
   - CodeIgniter\PHPStan\Rules\Classes\FrameworkExceptionInstantiationRule
+  - CodeIgniter\PHPStan\Rules\Functions\NoClassConstFetchOnFactoriesFunctions
   - CodeIgniter\PHPStan\Rules\Superglobals\SuperglobalAccessRule
   - CodeIgniter\PHPStan\Rules\Superglobals\SuperglobalAssignRule

src/Rules/Functions/NoClassConstFetchOnFactoriesFunctions.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) 2023 CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\PHPStan\Rules\Functions;
+
+use CodeIgniter\PHPStan\Type\FactoriesReturnTypeHelper;
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements Rule<Node\Expr\FuncCall>
+ */
+final class NoClassConstFetchOnFactoriesFunctions implements Rule
+{
+    public function __construct(
+        private readonly ReflectionProvider $reflectionProvider,
+        private readonly FactoriesReturnTypeHelper $factoriesReturnTypeHelper
+    ) {}
+
+    public function getNodeType(): string
+    {
+        return Node\Expr\FuncCall::class;
+    }
+
+    /**
+     * @param Node\Expr\FuncCall $node
+     */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (! $node->name instanceof Node\Name) {
+            return [];
+        }
+
+        $nameNode = $node->name;
+        $function = $this->reflectionProvider->resolveFunctionName($nameNode, $scope);
+
+        if (! in_array($function, ['config', 'model'], true)) {
+            return [];
+        }
+
+        $args = $node->getArgs();
+
+        if ($args === []) {
+            return [];
+        }
+
+        $classConstFetch = $args[0]->value;
+
+        if (! $classConstFetch instanceof Node\Expr\ClassConstFetch) {
+            return [];
+        }
+
+        if (! $classConstFetch->class instanceof Node\Name) {
+            return [];
+        }
+
+        if (! $classConstFetch->name instanceof Node\Identifier || $classConstFetch->name->name !== 'class') {
+            return [];
+        }
+
+        $returnType = $this->factoriesReturnTypeHelper->check($scope->getType($classConstFetch), $function);
+
+        if ($returnType->isNull()->yes()) {
+            return [];
+        }
+
+        $reflections = $returnType->getObjectClassReflections();
+
+        if ($reflections === []) {
+            return [];
+        }
+
+        return [
+            RuleErrorBuilder::message(sprintf(
+                'Call to function %s with %s::class is discouraged.',
+                $function,
+                $reflections[0]->getDisplayName()
+            ))->tip(sprintf(
+                'Use %s(\'%s\') instead to allow overriding.',
+                $function,
+                $reflections[0]->getNativeReflection()->getShortName()
+            ))->identifier('codeigniter.factoriesClassConstFetch')->build(),
+        ];
+    }
+}

tests/Rules/Functions/NoClassConstFetchOnFactoriesFunctionsTest.php

@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) 2023 CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\PHPStan\Tests\Rules\Functions;
+
+use CodeIgniter\PHPStan\Rules\Functions\NoClassConstFetchOnFactoriesFunctions;
+use CodeIgniter\PHPStan\Tests\AdditionalConfigFilesTrait;
+use CodeIgniter\PHPStan\Type\FactoriesReturnTypeHelper;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\Group;
+
+/**
+ * @internal
+ *
+ * @extends RuleTestCase<NoClassConstFetchOnFactoriesFunctions>
+ */
+#[Group('Integration')]
+final class NoClassConstFetchOnFactoriesFunctionsTest extends RuleTestCase
+{
+    use AdditionalConfigFilesTrait;
+
+    protected function getRule(): Rule
+    {
+        return new NoClassConstFetchOnFactoriesFunctions(
+            self::createReflectionProvider(),
+            self::getContainer()->getByType(FactoriesReturnTypeHelper::class)
+        );
+    }
+
+    public function testRule(): void
+    {
+        $this->analyse([
+            __DIR__ . '/../../Fixtures/Type/config.php',
+            __DIR__ . '/../../Fixtures/Type/model.php',
+        ], [
+            [
+                'Call to function config with Config\App::class is discouraged.',
+                26,
+                'Use config(\'App\') instead to allow overriding.',
+            ],
+            [
+                'Call to function model with stdClass::class is discouraged.',
+                19,
+                'Use model(\'stdClass\') instead to allow overriding.',
+            ],
+            [
+                'Call to function model with Closure::class is discouraged.',
+                20,
+                'Use model(\'Closure\') instead to allow overriding.',
+            ],
+        ]);
+    }
+}