Merge pull request #888 from rectorphp/local-collector

Add CallableCollectorPopulator

.travis.yml

@@ -38,7 +38,7 @@ script:
     - |
       if [[ $RUN_RECTOR == true ]]; then
           bin/rector process src --level symfony40 --dry-run
-          bin/rector generate-rector-overview >> rector-overview.md
+          bin/rector generate-docs >> rector-overview.md
       fi
 
     # Run standalone install in non-root package, ref https://github.com/rectorphp/rector/issues/732

composer.json

@@ -103,9 +103,8 @@
             "vendor/bin/ecs check bin packages src tests --fix",
             "bin/clean_trailing_spaces.sh"
         ],
-        "docs": "@update-docs",
         "phpstan": "vendor/bin/phpstan analyse packages src tests",
-        "update-docs": "bin/rector generate-rector-overview > docs/AllRectorsOverview.md",
+        "docs": "bin/rector generate-docs > docs/AllRectorsOverview.md",
         "pre-autoload-dump": [
             "Rector\\Tests\\Composer\\AutoloadWrongCasesEventSubscriber::preAutoloadDump"
         ]

packages/ContributorTools/src/Command/CreateRectorCommand.php

@@ -7,6 +7,7 @@ use Nette\Utils\Strings;
 use Rector\CodingStyle\AfterRectorCodingStyle;
 use Rector\ContributorTools\Configuration\Configuration;
 use Rector\ContributorTools\Configuration\ConfigurationFactory;
+use Rector\ContributorTools\Exception\Command\ContributorCommandInterface;
 use Rector\ContributorTools\TemplateVariablesFactory;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputInterface;
@@ -21,7 +22,7 @@ use function Safe\getcwd;
 use function Safe\sort;
 use function Safe\sprintf;
 
-final class CreateRectorCommand extends Command
+final class CreateRectorCommand extends Command implements ContributorCommandInterface
 {
     /**
      * @var string

packages/ContributorTools/src/Command/GenerateDocsCommand.php

@@ -1,12 +1,14 @@
 <?php declare(strict_types=1);
 
-namespace Rector\Console\Command;
+namespace Rector\ContributorTools\Command;
 
 use Nette\Loaders\RobotLoader;
 use Nette\Utils\Strings;
+use Rector\Console\Command\AbstractCommand;
 use Rector\Console\Shell;
 use Rector\ConsoleDiffer\MarkdownDifferAndFormatter;
 use Rector\Contract\Rector\RectorInterface;
+use Rector\ContributorTools\Exception\Command\ContributorCommandInterface;
 use Rector\Error\ExceptionCorrector;
 use Rector\Exception\ShouldNotHappenException;
 use Rector\RectorDefinition\ConfiguredCodeSample;
@@ -19,7 +21,7 @@ use Symplify\PackageBuilder\Console\Command\CommandNaming;
 use function Safe\ksort;
 use function Safe\sprintf;
 
-final class GenerateRectorOverviewCommand extends AbstractCommand
+final class GenerateDocsCommand extends AbstractCommand implements ContributorCommandInterface
 {
     /**
      * @var SymfonyStyle
@@ -94,7 +96,7 @@ final class GenerateRectorOverviewCommand extends AbstractCommand
      */
     private function getProjectsRectors(): array
     {
-        return $this->getRectorsFromDirectory([__DIR__ . '/../../../packages']);
+        return $this->getRectorsFromDirectory([__DIR__ . '/../../../../packages']);
     }
 
     /**
@@ -119,7 +121,7 @@ final class GenerateRectorOverviewCommand extends AbstractCommand
      */
     private function getGeneralRectors(): array
     {
-        return $this->getRectorsFromDirectory([__DIR__ . '/../../../src']);
+        return $this->getRectorsFromDirectory([__DIR__ . '/../../../../src']);
     }
 
     private function detectGroupFromRectorClass(string $rectorClass): string

packages/ContributorTools/src/Exception/Command/ContributorCommandInterface.php

@@ -0,0 +1,7 @@
+<?php declare(strict_types=1);
+
+namespace Rector\ContributorTools\Exception\Command;
+
+interface ContributorCommandInterface
+{
+}

packages/NodeTypeResolver/src/StaticTypeToStringResolver.php

@@ -13,21 +13,50 @@ use PHPStan\Type\ObjectType;
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\UnionType;
+use Rector\Collector\CallableCollectorPopulator;
 
 final class StaticTypeToStringResolver
 {
     /**
-     * @var string[]
+     * @var callable[]
      */
-    private $typeClassToTypeHint = [
-        CallableType::class => 'callable',
-        ClosureType::class => 'callable',
-        IntegerType::class => 'int',
-        FloatType::class => 'float',
-        BooleanType::class => 'bool',
-        StringType::class => 'string',
-        NullType::class => 'null',
-    ];
+    private $resolversByArgumentType = [];
+
+    public function __construct(CallableCollectorPopulator $callableCollectorPopulator)
+    {
+        $resolvers = [
+            IntegerType::class => ['int'],
+            ClosureType::class => ['callable'],
+            CallableType::class => ['callable'],
+            FloatType::class => ['float'],
+            BooleanType::class => ['bool'],
+            StringType::class => ['string'],
+            NullType::class => ['null'],
+            // more complex callables
+            function (ArrayType $arrayType): array {
+                $types = $this->resolve($arrayType->getItemType());
+                foreach ($types as $key => $type) {
+                    $types[$key] = $type . '[]';
+                }
+
+                return $types;
+            },
+            function (UnionType $unionType): array {
+                $types = [];
+                foreach ($unionType->getTypes() as $singleStaticType) {
+                    $types = array_merge($types, $this->resolve($singleStaticType));
+                }
+
+                return $types;
+            },
+            function (ObjectType $objectType): array {
+                // the must be absolute, since we have no other way to check absolute/local path
+                return ['\\' . $objectType->getClassName()];
+            },
+        ];
+
+        $this->resolversByArgumentType = $callableCollectorPopulator->populate($resolvers);
+    }
 
     /**
      * @return string[]
@@ -38,51 +67,12 @@ final class StaticTypeToStringResolver
             return [];
         }
 
-        foreach ($this->typeClassToTypeHint as $typeClass => $typeHint) {
-            if (is_a($staticType, $typeClass, true)) {
-                return [$typeHint];
+        foreach ($this->resolversByArgumentType as $type => $resolverCallable) {
+            if (is_a($staticType, $type, true)) {
+                return $resolverCallable($staticType);
             }
         }
 
-        if ($staticType instanceof UnionType) {
-            return $this->resolveUnionType($staticType);
-        }
-
-        if ($staticType instanceof ArrayType) {
-            return $this->resolveArrayType($staticType);
-        }
-
-        if ($staticType instanceof ObjectType) {
-            // the must be absolute, since we have no other way to check absolute/local path
-            return ['\\' . $staticType->getClassName()];
-        }
-
         return [];
     }
-
-    /**
-     * @return string[]
-     */
-    private function resolveUnionType(UnionType $unionType): array
-    {
-        $types = [];
-        foreach ($unionType->getTypes() as $singleStaticType) {
-            $types = array_merge($types, $this->resolve($singleStaticType));
-        }
-
-        return $types;
-    }
-
-    /**
-     * @return string[]
-     */
-    private function resolveArrayType(ArrayType $arrayType): array
-    {
-        $types = $this->resolve($arrayType->getItemType());
-        foreach ($types as $key => $type) {
-            $types[$key] = $type . '[]';
-        }
-
-        return $types;
-    }
 }

packages/Php/src/Rector/Property/CompleteVarDocTypePropertyRector.php

@@ -122,7 +122,6 @@ CODE_SAMPLE
     }
 
     /**
-     * @todo extract
      * Based on static analysis of code, looking for property assigns
      */
     private function resolveStaticVarTypeInfo(Property $propertyNode): ?VarTypeInfo

phpstan.neon

@@ -52,6 +52,7 @@ parameters:
 
         # irelevant
         - '#Call to function in_array\(\) with arguments string, (.*?) and true will always evaluate to false#'
+        - '#Parameter \#1 \$name of class ReflectionFunction constructor expects Closure\|string, callable given#'
 
         # known values
         - '#Access to an undefined property PhpParser\\Node\\Expr::\$left#'
@@ -70,6 +71,7 @@ parameters:
         - '#Access to an undefined property PhpParser\\Node::\$(\w+)#'
         - '#Parameter \#2 \$boolConstFetchNode of method Rector\\CodeQuality\\Rector\\Identical\\SimplifyArraySearchRector::resolveIsNot\(\) expects PhpParser\\Node\\Expr\\ConstFetch, PhpParser\\Node given#'
         - '#Method Rector\\PhpParser\\Node\\BetterNodeFinder::findFirstAncestorInstanceOf\(\) should return PhpParser\\Node\|null but returns object#'
+        - '#Parameter \#1 \$callables of method Rector\\Collector\\CallableCollectorPopulator::populate\(\) expects array<callable\|string>, (.*?) given#'
 
         # false positive, resolved in previous method
         - '#Parameter (.*?) of method Rector\\PhpParser\\Node\\Maintainer\\IdentifierMaintainer\:\:(.*?)\(\) expects PhpParser\\Node\\Expr\\ClassConstFetch\|PhpParser\\Node\\Expr\\MethodCall\|PhpParser\\Node\\Expr\\PropertyFetch\|PhpParser\\Node\\Expr\\StaticCall\|PhpParser\\Node\\Stmt\\ClassMethod, PhpParser\\Node given#'

src/Collector/CallableCollectorPopulator.php

@@ -0,0 +1,84 @@
+<?php declare(strict_types=1);
+
+namespace Rector\Collector;
+
+use Closure;
+use Rector\Exception\DependencyInjection\CallableCollectorException;
+use ReflectionFunction;
+use function Safe\sprintf;
+
+final class CallableCollectorPopulator
+{
+    /**
+     * @param string[]|callable[]|Closure[] $callables
+     * @return callable[]
+     */
+    public function populate(array $callables): array
+    {
+        $populatedCallables = [];
+
+        foreach ($callables as $key => $callable) {
+            // 1. convert instant assign to callable
+            if (! is_callable($callable)) {
+                $populatedCallables[$key] = function () use ($callable) {
+                    return $callable;
+                };
+                continue;
+            }
+
+            $parameterType = $this->resolveCallableParameterType($callable);
+            $this->ensureCallableParameterIsUnique($populatedCallables, $parameterType);
+
+            $populatedCallables[$parameterType] = $callable;
+        }
+
+        return $populatedCallables;
+    }
+
+    private function resolveCallableParameterType(callable $callable): string
+    {
+        $reflectionFunction = new ReflectionFunction($callable);
+        $this->ensureCallableHasExactlyOneParameter($reflectionFunction);
+
+        $reflectionParameter = $reflectionFunction->getParameters()[0];
+
+        $type = (string) $reflectionParameter->getType();
+        $this->ensureParameterHasType($type);
+
+        return $type;
+    }
+
+    /**
+     * @param callable[] $callables
+     */
+    private function ensureCallableParameterIsUnique(array $callables, string $parameterType): void
+    {
+        if (! isset($callables[$parameterType])) {
+            return;
+        }
+
+        throw new CallableCollectorException(sprintf(
+            'There can be only one callable for "%s" parameter type',
+            $parameterType
+        ));
+    }
+
+    private function ensureCallableHasExactlyOneParameter(ReflectionFunction $reflectionFunction): void
+    {
+        if ($reflectionFunction->getNumberOfParameters() !== 1) {
+            throw new CallableCollectorException(sprintf(
+                'Collector callable has to have exactly 1 parameter. %d found.',
+                $reflectionFunction->getNumberOfParameters()
+            ));
+        }
+    }
+
+    private function ensureParameterHasType(string $type): void
+    {
+        if ($type) {
+            return;
+        }
+
+        throw new CallableCollectorException('Collector callable parmaeter has to have type declaration.');
+    }
+}

src/Console/Application.php

@@ -3,8 +3,7 @@
 namespace Rector\Console;
 
 use Jean85\PrettyVersions;
-use Rector\Console\Command\GenerateRectorOverviewCommand;
-use Rector\ContributorTools\Command\CreateRectorCommand;
+use Rector\ContributorTools\Exception\Command\ContributorCommandInterface;
 use Symfony\Component\Console\Application as SymfonyApplication;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputDefinition;
@@ -12,7 +11,6 @@ use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
-use Symplify\PackageBuilder\Console\Command\CommandNaming;
 use function Safe\getcwd;
 use function Safe\realpath;
 
@@ -47,7 +45,7 @@ final class Application extends SymfonyApplication
         $shouldFollowByNewline = false;
 
         // skip in this case, since generate content must be clear from meta-info
-        if ($input->getFirstArgument() === CommandNaming::classToName(GenerateRectorOverviewCommand::class)) {
+        if (is_a($input->getFirstArgument(), ContributorCommandInterface::class, true)) {
             return parent::doRun($input, $output);
         }
 
@@ -92,11 +90,7 @@ final class Application extends SymfonyApplication
         }
 
         $filteredCommands = array_filter($commands, function (Command $command): bool {
-            return ! in_array(
-                get_class($command),
-                [CreateRectorCommand::class, GenerateRectorOverviewCommand::class],
-                true
-            );
+            return ! $command instanceof ContributorCommandInterface;
         });
 
         return array_values($filteredCommands);

src/Exception/DependencyInjection/CallableCollectorException.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace Rector\Exception\DependencyInjection;
+
+use Exception;
+
+final class CallableCollectorException extends Exception
+{
+}

src/PhpParser/Node/Resolver/NameResolver.php

@@ -13,6 +13,7 @@ use PhpParser\Node\Stmt\ClassConst;
 use PhpParser\Node\Stmt\Interface_;
 use PhpParser\Node\Stmt\Property;
 use PhpParser\Node\Stmt\Use_;
+use Rector\Collector\CallableCollectorPopulator;
 use Rector\NodeTypeResolver\Node\Attribute;
 
 final class NameResolver
@@ -22,64 +23,60 @@ final class NameResolver
      */
     private $nameResolversPerNode = [];
 
-    public function __construct()
+    public function __construct(CallableCollectorPopulator $callableCollectorPopulator)
     {
-        $this->nameResolversPerNode[ClassConst::class] = function (ClassConst $classConstNode) {
-            if (! count($classConstNode->consts)) {
-                return null;
-            }
+        $resolvers = [
+            Empty_::class => 'empty',
+            // more complex
+            function (ClassConst $classConstNode): ?string {
+                if (! count($classConstNode->consts)) {
+                    return null;
+                }
 
-            return $this->resolve($classConstNode->consts[0]);
-        };
+                return $this->resolve($classConstNode->consts[0]);
+            },
+            function (Property $propertyNode): ?string {
+                if (! count($propertyNode->props)) {
+                    return null;
+                }
 
-        $this->nameResolversPerNode[Property::class] = function (Property $propertyNode): ?string {
-            if (! count($propertyNode->props)) {
-                return null;
-            }
+                return $this->resolve($propertyNode->props[0]);
+            },
+            function (Use_ $useNode): ?string {
+                if (! count($useNode->uses)) {
+                    return null;
+                }
 
-            return $this->resolve($propertyNode->props[0]);
-        };
+                return $this->resolve($useNode->uses[0]);
+            },
+            function (Param $paramNode): ?string {
+                return $this->resolve($paramNode->var);
+            },
+            function (Name $nameNode): string {
+                $resolvedName = $nameNode->getAttribute(Attribute::RESOLVED_NAME);
+                if ($resolvedName instanceof FullyQualified) {
+                    return $resolvedName->toString();
+                }
 
-        $this->nameResolversPerNode[Use_::class] = function (Use_ $useNode): ?string {
-            if (! count($useNode->uses)) {
-                return null;
-            }
+                return $nameNode->toString();
+            },
+            function (Class_ $classNode): ?string {
+                if (isset($classNode->namespacedName)) {
+                    return $classNode->namespacedName->toString();
+                }
 
-            return $this->resolve($useNode->uses[0]);
-        };
+                return $this->resolve($classNode->name);
+            },
+            function (Interface_ $interfaceNode): ?string {
+                if (isset($interfaceNode->namespacedName)) {
+                    return $interfaceNode->namespacedName->toString();
+                }
 
-        $this->nameResolversPerNode[Param::class] = function (Param $paramNode): ?string {
-            return $this->resolve($paramNode->var);
-        };
+                return $this->resolve($interfaceNode->name);
+            },
+        ];
 
-        $this->nameResolversPerNode[Name::class] = function (Name $nameNode): string {
-            $resolvedName = $nameNode->getAttribute(Attribute::RESOLVED_NAME);
-            if ($resolvedName instanceof FullyQualified) {
-                return $resolvedName->toString();
-            }
-
-            return $nameNode->toString();
-        };
-
-        $this->nameResolversPerNode[Empty_::class] = function (): string {
-            return 'empty';
-        };
-
-        $this->nameResolversPerNode[Class_::class] = function (Class_ $classNode): ?string {
-            if (isset($classNode->namespacedName)) {
-                return $classNode->namespacedName->toString();
-            }
-
-            return $this->resolve($classNode->name);
-        };
-
-        $this->nameResolversPerNode[Interface_::class] = function (Interface_ $interfaceNode): ?string {
-            if (isset($interfaceNode->namespacedName)) {
-                return $interfaceNode->namespacedName->toString();
-            }
-
-            return $this->resolve($interfaceNode->name);
-        };
+        $this->nameResolversPerNode = $callableCollectorPopulator->populate($resolvers);
     }
 
     public function isName(Node $node, string $name): bool