[PHPStan] Merge remote-tracking branch 'origin/master' into PHPStan

# Conflicts:
#	composer.json
#	composer.lock

Author: lkck24

src/FactoryInterface.php

@@ -1,8 +1,9 @@
 <?php
 
+declare(strict_types=1);
+
 namespace Cubicl\ObjectGraphGenerator;
 
-use Cubicl\ObjectGraphGenerator\ObjectGraphGenerator;
 use Faker\Generator;
 
 interface FactoryInterface

src/ObjectGraphGenerator.php

@@ -19,35 +19,40 @@ class ObjectGraphGenerator
 {
     private const DEFAULT_SEED = 1;
 
-    /** @var Generator */
-    private $fakerInstance;
-
-    /** @var PropertyInfoExtractor */
-    private $propertyInfo;
-
-    /** @var array */
-    private $registry;
-
-    /** @var array */
-    private $temporaryRegistry = [];
+    private Generator $fakerInstance;
+    private PropertyInfoExtractor $propertyInfo;
+    /** @var array<mixed> */
+    private array $registry;
+    /** @var array<mixed> */
+    private array $temporaryRegistry = [];
 
+    /**
+     * @param array<mixed> $registry
+     */
     public function __construct(array $registry = [])
     {
         $this->fakerInstance = Factory::create();
 
-        $phpDocExtractor     = new PhpDocExtractor();
+        $phpDocExtractor = new PhpDocExtractor();
         $reflectionExtractor = new ReflectionExtractor();
-        $typeExtractors      = [$phpDocExtractor, $reflectionExtractor];
-        $this->propertyInfo  = new PropertyInfoExtractor([], $typeExtractors, [], [], []);
+        $typeExtractors = [$phpDocExtractor, $reflectionExtractor];
+        $this->propertyInfo = new PropertyInfoExtractor([], $typeExtractors, [], [], []);
         $this->fakerInstance->seed(self::DEFAULT_SEED);
         $this->registry = $registry;
     }
 
+    /**
+     * @param class-string $className
+     */
     public function generate(string $className): object
     {
         return $this->generateObject($className);
     }
 
+    /**
+     * @param class-string $className
+     * @param array<mixed> $config
+     */
     public function generateWithTemporaryConfig(string $className, array $config): object
     {
         $this->temporaryRegistry = $config;
@@ -58,18 +63,16 @@ public function generateWithTemporaryConfig(string $className, array $config): o
     }
 
     /**
-     * @param string $className
-     *
-     * @return mixed|object
+     * @param class-string $className
      * @throws ReflectionException
      */
-    private function generateObject(string $className)
+    private function generateObject(string $className): object
     {
         if ($this->isInRegistry($className)) {
             return $this->getFromRegistry($className);
         }
 
-        $class         = new ReflectionClass($className);
+        $class = new ReflectionClass($className);
         $factoryMethod = $this->findFactoryMethod($class);
 
         if ($factoryMethod === null) {
@@ -78,6 +81,7 @@ private function generateObject(string $className)
 
         $arguments = array_map(
             function (ReflectionParameter $parameter) use ($className) {
+                /** @var array<mixed> $type */
                 $type = $this->propertyInfo->getTypes($className, $parameter->getName());
 
                 return $this->generateArgument($type[0], $className, $parameter->getName());
@@ -90,13 +94,17 @@ function (ReflectionParameter $parameter) use ($className) {
             : $factoryMethod->invokeArgs(null, $arguments);
     }
 
+    /**
+     * @param ReflectionClass<object> $class
+     */
     private function findFactoryMethod(ReflectionClass $class): ?ReflectionMethod
     {
         try {
             return $class->getMethod('createNew');
         } catch (ReflectionException $e) {
             // Do nothing here
         }
+
         try {
             return $class->getMethod('create');
         } catch (ReflectionException $e) {
@@ -105,47 +113,57 @@ private function findFactoryMethod(ReflectionClass $class): ?ReflectionMethod
     }
 
     /**
-     * @param Type   $type
-     *
-     * @param string $className
-     * @param string $argumentName
-     *
      * @return mixed
      * @throws ReflectionException
      */
     private function generateArgument(Type $type, string $className, string $argumentName)
     {
         $faker = $type->isNullable() ? $this->fakerInstance->optional() : $this->fakerInstance;
         $key = sprintf('%s:%s', $className, $argumentName);
+
         if ($this->isInRegistry($key)) {
             return $this->getFromRegistry($key);
         }
 
         switch ($type->getBuiltinType()) {
             case Type::BUILTIN_TYPE_INT:
                 return $faker->randomNumber(5);
+
             case Type::BUILTIN_TYPE_FLOAT:
                 return $faker->randomFloat();
+
             case Type::BUILTIN_TYPE_STRING:
                 return $faker->text(100);
+
             case Type::BUILTIN_TYPE_BOOL:
                 return $faker->boolean();
+
             case Type::BUILTIN_TYPE_ARRAY:
                 $collection = [];
+
                 if ($type->isCollection()) {
                     $collection = array_map(
                         function () use ($argumentName, $className, $type) {
-                            return $this->generateArgument($type->getCollectionValueType(), $className, $argumentName);
+                            /** @var Type $collectionValueType */
+                            $collectionValueType = $type->getCollectionValueType();
+
+                            return $this->generateArgument($collectionValueType, $className, $argumentName);
                         },
                         range(0, $faker->numberBetween(0, 10))
                     );
                 }
+
                 return $faker->passthrough($collection);
+
             case Type::BUILTIN_TYPE_OBJECT:
-                if ($type->getClassName() === 'DateTime') {
+                /** @var class-string $className */
+                $className = $type->getClassName();
+
+                if ($className === 'DateTime') {
                     return $faker->dateTime();
                 }
-                return $faker->passthrough($this->generateObject($type->getClassName()));
+
+                return $faker->passthrough($this->generateObject($className));
         }
     }
 
@@ -154,11 +172,15 @@ private function isInRegistry(string $key): bool
         return array_key_exists($key, $this->temporaryRegistry) || array_key_exists($key, $this->registry);
     }
 
+    /**
+     * @return mixed
+     */
     private function getFromRegistry(string $key)
     {
         if (isset($this->temporaryRegistry[$key])) {
             return $this->temporaryRegistry[$key]($this, $this->fakerInstance);
         }
+
         return $this->registry[$key]($this, $this->fakerInstance);
     }
 }