Revamp Factories return type extension and argument type rule

Author: paulbalandan

docs/rules.md

@@ -23,6 +23,17 @@ using the `new` keyword. Instead, it directs users to use one of their named con
 
 ## Functions
 
+### FactoriesFunctionArgumentTypeRule
+
+**Class:** `CodeIgniter\PHPStan\Rules\Functions\FactoriesFunctionArgumentTypeRule`<br/>
+Fixable: No
+
+This rule validates the class string passed to either the `config()` or `model()` function. It reports
+a passed string that does not resolve to a known class, and, when enabled, a resolved class that does not
+extend `CodeIgniter\Config\BaseConfig` or `CodeIgniter\Model` respectively. The rule is registered only
+when `codeigniter.checkArgumentTypeOfFactories` is `true`, and the per-function instance checks are
+toggled by `codeigniter.checkArgumentTypeOfConfig` and `codeigniter.checkArgumentTypeOfModel`.
+
 ### ServicesFunctionArgumentTypeRule
 
 **Class:** `CodeIgniter\PHPStan\Rules\Functions\ServicesFunctionArgumentTypeRule`<br/>

docs/type-inference.md

@@ -23,6 +23,27 @@ This extension provides precise return types for the `service()` and `single_ser
 >       - Acme\Blog\Config\Services
 > ```
 
+### FactoriesFunctionReturnTypeExtension
+
+**Class:** `CodeIgniter\PHPStan\Type\FactoriesFunctionReturnTypeExtension`
+
+This extension provides precise return types for the `config()` and `model()` functions, resolving the
+class from the passed name or class string.
+
+> [!NOTE]
+> **Configuration:**
+>
+> You can instruct PHPStan to consider additional namespaces when resolving the passed name to a class.
+>
+> ```yml
+> parameters:
+>   codeigniter:
+>     additionalConfigNamespaces:
+>       - Acme\Blog\Config\
+>     additionalModelNamespaces:
+>       - Acme\Blog\Models\
+> ```
+
 ## Dynamic Method Return Type Extensions
 
 ### ReflectionHelperMethodInvokerStaticReturnTypeExtension

extension.neon

@@ -6,14 +6,31 @@ parameters:
   universalObjectCratesClasses:
     - CodeIgniter\Entity\Entity
   codeigniter:
+    additionalConfigNamespaces:
+      - CodeIgniter\Config\
+    additionalModelNamespaces: []
     additionalServices: []
+    checkArgumentTypeOfConfig: true
+    checkArgumentTypeOfModel: true
+    checkArgumentTypeOfFactories: true
 
 parametersSchema:
   codeigniter: structure([
+    additionalConfigNamespaces: listOf(string())
+    additionalModelNamespaces: listOf(string())
     additionalServices: listOf(string())
+    checkArgumentTypeOfConfig: bool()
+    checkArgumentTypeOfModel: bool()
+    checkArgumentTypeOfFactories: bool()
   ])
 
 services:
+  factoriesReturnTypeHelper:
+    class: CodeIgniter\PHPStan\Helpers\FactoriesReturnTypeHelper
+    arguments:
+      additionalConfigNamespaces: %codeigniter.additionalConfigNamespaces%
+      additionalModelNamespaces: %codeigniter.additionalModelNamespaces%
+
   reflectionHelperPrivateInvokerHelper:
     class: CodeIgniter\PHPStan\Helpers\ReflectionHelperPrivateInvokerHelper
 
@@ -49,6 +66,11 @@ services:
     tags:
       - phpstan.broker.dynamicStaticMethodReturnTypeExtension
 
+  -
+    class: CodeIgniter\PHPStan\Type\FactoriesFunctionReturnTypeExtension
+    tags:
+      - phpstan.broker.dynamicFunctionReturnTypeExtension
+
   -
     class: CodeIgniter\PHPStan\Type\ServicesFunctionReturnTypeExtension
     tags:
@@ -64,6 +86,16 @@ services:
     tags:
       - phpstan.broker.dynamicStaticMethodReturnTypeExtension
 
+  -
+    class: CodeIgniter\PHPStan\Rules\Functions\FactoriesFunctionArgumentTypeRule
+    arguments:
+      checkArgumentTypeOfConfig: %codeigniter.checkArgumentTypeOfConfig%
+      checkArgumentTypeOfModel: %codeigniter.checkArgumentTypeOfModel%
+
+conditionalTags:
+  CodeIgniter\PHPStan\Rules\Functions\FactoriesFunctionArgumentTypeRule:
+    phpstan.rules.rule: %codeigniter.checkArgumentTypeOfFactories%
+
 rules:
   - CodeIgniter\PHPStan\Rules\Classes\FrameworkExceptionInstantiationRule
   - CodeIgniter\PHPStan\Rules\Superglobals\SuperglobalsGlobalAssignRule

src/Type/FactoriesReturnTypeHelper.php src/Helpers/FactoriesReturnTypeHelper.phpsrc/Type/FactoriesReturnTypeHelper.php renamed to src/Helpers/FactoriesReturnTypeHelper.php

@@ -11,7 +11,7 @@
  * the LICENSE file that was distributed with this source code.
  */
 
-namespace CodeIgniter\PHPStan\Type;
+namespace CodeIgniter\PHPStan\Helpers;
 
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\IntersectionType;
@@ -34,10 +34,7 @@ final class FactoriesReturnTypeHelper
     /**
      * @var array<string, list<string>>
      */
-    private array $additionalNamespacesMap = [
-        'config' => [],
-        'model'  => [],
-    ];
+    private array $additionalNamespacesMap;
 
     /**
      * @param list<string> $additionalConfigNamespaces
@@ -51,8 +48,8 @@ public function __construct(
         $cb = static fn (string $item): string => rtrim($item, '\\') . '\\';
 
         $this->additionalNamespacesMap = [
-            'config' => [...$this->additionalNamespacesMap['config'], ...array_map($cb, $additionalConfigNamespaces)],
-            'model'  => [...$this->additionalNamespacesMap['model'], ...array_map($cb, $additionalModelNamespaces)],
+            'config' => array_map($cb, $additionalConfigNamespaces),
+            'model'  => array_map($cb, $additionalModelNamespaces),
         ];
     }
 

src/Rules/Functions/FactoriesFunctionArgumentTypeRule.php

@@ -15,7 +15,7 @@
 
 use CodeIgniter\Config\BaseConfig;
 use CodeIgniter\Model;
-use CodeIgniter\PHPStan\Type\FactoriesReturnTypeHelper;
+use CodeIgniter\PHPStan\Helpers\FactoriesReturnTypeHelper;
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ParametersAcceptorSelector;
@@ -41,7 +41,7 @@ final class FactoriesFunctionArgumentTypeRule implements Rule
     /**
      * @var array<string, bool>
      */
-    private array $argumentTypeCheck = [];
+    private array $argumentTypeCheck;
 
     public function __construct(
         private readonly ReflectionProvider $reflectionProvider,
@@ -85,47 +85,48 @@ public function processNode(Node $node, Scope $scope): array
             return []; // caught elsewhere
         }
 
-        $returnType = $this->factoriesReturnTypeHelper->check($nameType, $function);
-
+        $returnType     = $this->factoriesReturnTypeHelper->check($nameType, $function);
         $firstParameter = ParametersAcceptorSelector::selectFromArgs(
             $scope,
-            $node->getArgs(),
+            $args,
             $this->reflectionProvider->getFunction($nameNode, $scope)->getVariants(),
         )->getParameters()[0];
 
         if ($returnType->isNull()->yes()) {
-            $addTip = static function (RuleErrorBuilder $ruleErrorBuilder) use ($nameType, $function): RuleErrorBuilder {
-                foreach ($nameType->getConstantStrings() as $constantStringType) {
-                    $ruleErrorBuilder->addTip(sprintf(
-                        'If %s is a valid class string, you can add its possible namespace(s) in <fg=cyan>codeigniter.additional%sNamespaces</> in your <fg=yellow>%%configurationFile%%</>.',
-                        $constantStringType->describe(VerbosityLevel::precise()),
-                        ucfirst($function),
-                    ));
-                }
-
-                return $ruleErrorBuilder;
-            };
-
-            return [$addTip(RuleErrorBuilder::message(sprintf(
+            $ruleErrorBuilder = RuleErrorBuilder::message(sprintf(
                 'Parameter #1 $%s of function %s expects a valid class string, %s given.',
                 $firstParameter->getName(),
                 $function,
                 $nameType->describe(VerbosityLevel::precise()),
-            )))->identifier(sprintf('codeigniter.%sArgumentType', $function))->build()];
+            ))->identifier(sprintf('codeigniter.%sArgumentType', $function));
+
+            foreach ($nameType->getConstantStrings() as $constantStringType) {
+                $ruleErrorBuilder->addTip(sprintf(
+                    'If %s is a valid class string, you can add its possible namespace(s) in <fg=cyan>codeigniter.additional%sNamespaces</> in your <fg=yellow>%%configurationFile%%</>.',
+                    $constantStringType->describe(VerbosityLevel::precise()),
+                    ucfirst($function),
+                ));
+            }
+
+            return [$ruleErrorBuilder->build()];
         }
 
         if (! (new ObjectType($this->instanceofMap[$function]))->isSuperTypeOf($returnType)->yes()) {
             if (! $this->argumentTypeCheck[$function]) {
                 return [];
             }
 
-            return [RuleErrorBuilder::message(sprintf(
-                'Argument #1 $%s (%s) passed to function %s does not extend %s.',
-                $firstParameter->getName(),
-                $nameType->describe(VerbosityLevel::precise()),
-                $function,
-                addcslashes($this->instanceofMap[$function], '\\'),
-            ))->identifier(sprintf('codeigniter.%sArgumentInstanceof', $function))->build()];
+            return [
+                RuleErrorBuilder::message(sprintf(
+                    'Argument #1 $%s (%s) passed to function %s does not extend %s.',
+                    $firstParameter->getName(),
+                    $nameType->describe(VerbosityLevel::precise()),
+                    $function,
+                    $this->instanceofMap[$function],
+                ))
+                    ->identifier(sprintf('codeigniter.%sArgumentInstanceof', $function))
+                    ->build(),
+            ];
         }
 
         return [];

src/Rules/Functions/NoClassConstFetchOnFactoriesFunctions.php

@@ -13,6 +13,7 @@
 
 namespace CodeIgniter\PHPStan\Type;
 
+use CodeIgniter\PHPStan\Helpers\FactoriesReturnTypeHelper;
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\FunctionReflection;
@@ -32,14 +33,14 @@ public function isFunctionSupported(FunctionReflection $functionReflection): boo
 
     public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, Scope $scope): ?Type
     {
-        $arguments = $functionCall->getArgs();
+        $args = $functionCall->getArgs();
 
-        if ($arguments === []) {
+        if ($args === []) {
             return null;
         }
 
         return $this->factoriesReturnTypeHelper->check(
-            $scope->getType($arguments[0]->value),
+            $scope->getType($args[0]->value),
             $functionReflection->getName(),
         );
     }

src/Type/FactoriesFunctionReturnTypeExtension.php

@@ -11,7 +11,7 @@
  * the LICENSE file that was distributed with this source code.
  */
 
-namespace CodeIgniter\PHPStan\Tests\Fixtures\Type;
+namespace CodeIgniter\PHPStan\Tests\Fixtures;
 
 use CodeIgniter\Model;