phsptan fixes

Author: TomasVotruba

composer.json

@@ -8,21 +8,24 @@
         "ext-xml": "*"
     },
     "require-dev": {
+        "phpecs/phpecs": "^2.0.1",
         "phpstan/extension-installer": "^1.4",
         "phpstan/phpstan": "^2.1.8",
         "phpstan/phpstan-webmozart-assert": "^2.0",
         "phpunit/phpunit": "^11.4",
         "rector/rector-src": "dev-main",
+        "rector/type-perfect": "^2.0",
         "symfony/config": "^6.4",
         "symfony/dependency-injection": "^6.4",
         "symfony/http-kernel": "^6.4",
         "symfony/routing": "^6.4",
         "symfony/security-core": "^6.4",
         "symfony/security-http": "^6.4",
         "symfony/validator": "^6.4",
-        "phpecs/phpecs": "^2.0.1",
         "symplify/vendor-patches": "^11.3",
         "tomasvotruba/class-leak": "^2.0",
+        "tomasvotruba/type-coverage": "^2.0",
+        "tomasvotruba/unused-public": "^2.0",
         "tracy/tracy": "^2.10"
     },
     "autoload": {

config/sets/symfony/symfony73.php

@@ -3,8 +3,9 @@
 declare(strict_types=1);
 
 use Rector\Config\RectorConfig;
+use Rector\Symfony\Symfony73\Rector\Class_\InvokableCommandRector;
 
 // @see https://github.com/symfony/symfony/blame/7.3/UPGRADE-7.3.md
 
 return RectorConfig::configure()
-    ->withRules([]);
+    ->withRules([InvokableCommandRector::class]);

phpstan.neon

@@ -2,7 +2,6 @@ parameters:
     level: 8
 
     reportUnmatchedIgnoredErrors: false
-
     treatPhpDocTypesAsCertain: false
 
     paths:
@@ -12,18 +11,17 @@ parameters:
         - rules
         - rules-tests
 
-# to be enabled later once rector upgraded to use phpstan v2
-#    # https://github.com/rectorphp/type-perfect/
-#    type_perfect:
-#        no_mixed: true
-#        null_over_false: true
-#        narrow_param: true
-#        narrow_return: true
+    # https://github.com/rectorphp/type-perfect/
+    type_perfect:
+        no_mixed: true
+        null_over_false: true
+        narrow_param: true
+        narrow_return: true
 
-#    unused_public:
-#        constants: true
-#        methods: true
-#        properties: true
+    unused_public:
+        constants: true
+        methods: true
+        properties: true
 
     scanDirectories:
         - stubs
@@ -54,16 +52,12 @@ parameters:
         - '#Doing instanceof PHPStan\\Type\\.+ is error\-prone and deprecated#'
 
         # phpstan instanceof
-        -
-            identifier: phpstanApi.instanceofAssumption
-
-        -
-            identifier: phpstanApi.varTagAssumption
+        - identifier: argument.type
+        - identifier: assign.propertyType
 
-        -
-            identifier: argument.type
+        - '#::provideMinPhpVersion\(\) never returns \d+ so it can be removed from the return type#'
 
+        # node finder
         -
-            identifier: assign.propertyType
-
-        - '#::provideMinPhpVersion\(\) never returns \d+ so it can be removed from the return type#'
+            identifier: return.type
+            path: rules/Symfony73/NodeAnalyzer/CommandArgumentsAndOptionsResolver.php

rules-tests/Symfony73/Rector/Class_/InvokableCommandRector/Fixture/some_command.php

@@ -18,7 +18,7 @@ final class SomeCommand extends Command
         $this->addOption('option', 'o', InputOption::VALUE_NONE, 'Option description');
     }
 
-    public function execute(InputInterface $input, OutputInterface $output)
+    public function execute(InputInterface $input, OutputInterface $output): int
     {
         $someArgument = $input->getArgument('argument');
         $someOption = $input->getOption('option');
@@ -35,18 +35,20 @@ final class SomeCommand extends Command
 
 namespace Rector\Symfony\Tests\Symfony73\Rector\Class_\InvokableCommandRector\Fixture;
 
+use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Command\Command;
-use Symfony\Component\Console\Command\Argument;
-use Symfony\Component\Console\Command\Option;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputOption;
 
+#[AsCommand(name: 'some_name')]
 final class SomeCommand
 {
-    public function __invoke(
-        #[Argument]
-        string $argument,
-        #[Option]
-        bool $option = false,
-    ) {
+    public function __invoke(#[\Symfony\Component\Console\Attribute\Command\Argument]
+    string $argument, #[\Symfony\Component\Console\Attribute\Command\Option]
+    $option): int
+    {
         $someArgument = $argument;
         $someOption = $option;
 

rules-tests/Symfony73/Rector/Class_/InvokableCommandRector/Fixture/some_command.php.inc

@@ -19,8 +19,8 @@
 use PHPStan\Type\ObjectType;
 use Rector\PhpAttribute\NodeFactory\PhpAttributeGroupFactory;
 use Rector\Rector\AbstractRector;
-use Rector\Symfony\Enum\SymfonyAnnotation;
 use Rector\Symfony\Enum\SymfonyAttribute;
+use Rector\Symfony\Enum\SymfonyClass;
 use Rector\ValueObject\PhpVersionFeature;
 use Rector\VersionBonding\Contract\MinPhpVersionInterface;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
@@ -103,11 +103,11 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        if (! $this->reflectionProvider->hasClass(SymfonyAnnotation::AS_COMMAND)) {
+        if (! $this->reflectionProvider->hasClass(SymfonyAttribute::AS_COMMAND)) {
             return null;
         }
 
-        if (! $this->isObjectType($node, new ObjectType('Symfony\\Component\\Console\\Command\\Command'))) {
+        if (! $this->isObjectType($node, new ObjectType(SymfonyClass::COMMAND))) {
             return null;
         }
 
@@ -140,7 +140,7 @@ public function refactor(Node $node): ?Node
         }
 
         if (! $asCommandAttribute instanceof Attribute) {
-            $asCommandAttributeGroup = $this->phpAttributeGroupFactory->createFromClass(SymfonyAnnotation::AS_COMMAND);
+            $asCommandAttributeGroup = $this->phpAttributeGroupFactory->createFromClass(SymfonyAttribute::AS_COMMAND);
 
             $asCommandAttribute = $asCommandAttributeGroup->attrs[0];
 

rules/Symfony61/Rector/Class_/CommandConfigureToAttributeRector.php

@@ -6,23 +6,50 @@
 
 use PhpParser\Node;
 use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\NodeFinder;
 use Rector\Exception\ShouldNotHappenException;
-use Rector\Symfony\Symfony73\ValueObject\CommandOptionMetadata;
+use Rector\Symfony\Symfony73\ValueObject\CommandArgument;
+use Rector\Symfony\Symfony73\ValueObject\CommandOption;
 
 final class CommandArgumentsAndOptionsResolver
 {
     /**
-     * @return CommandOptionMetadata[]
+     * @return CommandArgument[]
      */
-    public function collectCommandOptionsMetadatas(ClassMethod $configureClassMethod): array
+    public function collectCommandArguments(ClassMethod $configureClassMethod): array
+    {
+        $addArgumentMethodCalls = $this->findMethodCallsByName($configureClassMethod, 'addArgument');
+
+        $commandArguments = [];
+        foreach ($addArgumentMethodCalls as $addArgumentMethodCall) {
+            // @todo extract name, type and requirements
+            $addArgumentArgs = $addArgumentMethodCall->getArgs();
+
+            $nameArgValue = $addArgumentArgs[0]->value;
+            if (! $nameArgValue instanceof String_) {
+                // we need string value, otherwise param will not have a name
+                throw new ShouldNotHappenException('Argument name is required');
+            }
+
+            $optionName = $nameArgValue->value;
+
+            $commandArguments[] = new CommandArgument($optionName);
+        }
+
+        return $commandArguments;
+    }
+
+    /**
+     * @return CommandOption[]
+     */
+    public function collectCommandOptions(ClassMethod $configureClassMethod): array
     {
         $addOptionMethodCalls = $this->findMethodCallsByName($configureClassMethod, 'addOption');
 
         $commandOptionMetadatas = [];
-
         foreach ($addOptionMethodCalls as $addOptionMethodCall) {
             // @todo extract name, type and requirements
             $addOptionArgs = $addOptionMethodCall->getArgs();
@@ -35,7 +62,7 @@ public function collectCommandOptionsMetadatas(ClassMethod $configureClassMethod
 
             $optionName = $nameArgValue->value;
 
-            $commandOptionMetadatas[] = new CommandOptionMetadata($optionName);
+            $commandOptionMetadatas[] = new CommandOption($optionName);
         }
 
         return $commandOptionMetadatas;
@@ -53,7 +80,7 @@ private function findMethodCallsByName(ClassMethod $classMethod, string $desired
                 return false;
             }
 
-            if (! $node->name instanceof Node\Identifier) {
+            if (! $node->name instanceof Identifier) {
                 return false;
             }
 

rules/Symfony73/NodeAnalyzer/CommandArgumentsAndOptionsResolver.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Symfony\Symfony73\NodeFactory;
+
+use PhpParser\Node\Attribute;
+use PhpParser\Node\AttributeGroup;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name\FullyQualified;
+use PhpParser\Node\Param;
+use Rector\Symfony\Enum\SymfonyAttribute;
+use Rector\Symfony\Symfony73\ValueObject\CommandArgument;
+use Rector\Symfony\Symfony73\ValueObject\CommandOption;
+
+final class CommandInvokeParamsFactory
+{
+    /**
+     * @param CommandArgument[] $commandArguments
+     * @param CommandOption[] $commandOptions
+     * @return Param[]
+     */
+    public function createParams(array $commandArguments, array $commandOptions): array
+    {
+        $argumentParams = $this->createArgumentParams($commandArguments);
+        $optionParams = $this->createOptionParams($commandOptions);
+
+        return array_merge($argumentParams, $optionParams);
+    }
+
+    /**
+     * @param CommandArgument[] $commandArguments
+     * @return Param[]
+     */
+    private function createArgumentParams(array $commandArguments): array
+    {
+        $argumentParams = [];
+
+        foreach ($commandArguments as $commandArgument) {
+            $argumentParam = new Param(new Variable($commandArgument->getName()));
+
+            $argumentParam->type = new Identifier('string');
+            // @todo fill type or default value
+            // @todo default string, multiple values array
+
+            $argumentParam->attrGroups[] = new AttributeGroup([
+                new Attribute(new FullyQualified(SymfonyAttribute::COMMAND_ARGUMENT)),
+            ]);
+
+            $argumentParams[] = $argumentParam;
+        }
+
+        return $argumentParams;
+    }
+
+    /**
+     * @param CommandOption[] $commandOptions
+     * @return Param[]
+     */
+    private function createOptionParams(array $commandOptions): array
+    {
+        $optionParams = [];
+
+        foreach ($commandOptions as $commandOption) {
+            $optionParam = new Param(new Variable($commandOption->getName()));
+
+            // @todo fill type or default value
+            $optionParam->attrGroups[] = new AttributeGroup([
+                new Attribute(new FullyQualified(SymfonyAttribute::COMMAND_OPTION)),
+            ]);
+
+            $optionParams[] = $optionParam;
+        }
+
+        return $optionParams;
+    }
+}