Merge pull request #85 from samsonasik/apply-php80

Ocramius · web-flow · commit 8d4074b5f51b · 2023-01-02T19:24:36.000+01:00
Apply PHP 8.0 Syntax and constructor promotion
diff --git a/src/CodeGenerator/AbstractInjector.php b/src/CodeGenerator/AbstractInjector.php
@@ -17,15 +17,12 @@ abstract class AbstractInjector implements InjectorInterface
     protected $factories = [];
 
     /** @var array<string, FactoryInterface> */
-    private $factoryInstances = [];
+    private array $factoryInstances = [];
 
     private ContainerInterface $container;
 
-    private InjectorInterface $injector;
-
-    public function __construct(InjectorInterface $injector, ?ContainerInterface $container = null)
+    public function __construct(private InjectorInterface $injector, ?ContainerInterface $container = null)
     {
-        $this->injector  = $injector;
         $this->container = $container ?: new DefaultContainer($this);
 
         $this->loadFactoryList();
diff --git a/src/CodeGenerator/AutoloadGenerator.php b/src/CodeGenerator/AutoloadGenerator.php
@@ -26,11 +26,8 @@ class AutoloadGenerator
     private const CLASS_TEMPLATE = __DIR__ . '/../../templates/autoloader-class.template';
     private const FILE_TEMPLATE  = __DIR__ . '/../../templates/autoloader-file.template';
 
-    private string $namespace;
-
-    public function __construct(string $namespace)
+    public function __construct(private string $namespace)
     {
-        $this->namespace = $namespace;
     }
 
     private function writeFile(string $filename, string $code): void
@@ -65,7 +62,7 @@ private function buildFromTemplate(string $templateFile, string $outputFile, arr
     private function generateClassmapCode(array &$classmap): string
     {
         $lines = array_map(
-            fn(string $class, string $file): string => sprintf(
+            static fn(string $class, string $file): string => sprintf(
                 '%s => %s,',
                 var_export($class, true),
                 var_export($file, true)
diff --git a/src/CodeGenerator/FactoryGenerator.php b/src/CodeGenerator/FactoryGenerator.php
@@ -48,20 +48,14 @@ class FactoryGenerator
 
     private string $namespace;
 
-    private DependencyResolverInterface $resolver;
-
-    private ConfigInterface $config;
-
     /** @var array<string, string> */
     private array $classmap = [];
 
     public function __construct(
-        ConfigInterface $config,
-        DependencyResolverInterface $resolver,
+        private ConfigInterface $config,
+        private DependencyResolverInterface $resolver,
         ?string $namespace = null
     ) {
-        $this->resolver  = $resolver;
-        $this->config    = $config;
         $this->namespace = $namespace ?: 'LaminasDiGenerated';
     }
 
diff --git a/src/CodeGenerator/InjectorGenerator.php b/src/CodeGenerator/InjectorGenerator.php
@@ -40,8 +40,6 @@ class InjectorGenerator
     private const INJECTOR_TEMPLATE     = __DIR__ . '/../../templates/injector.template';
     private const INDENTATION_SPACES    = 4;
 
-    private ConfigInterface $config;
-
     /**
      * @deprecated
      *
@@ -68,12 +66,11 @@ class InjectorGenerator
      *            and processed classes.
      */
     public function __construct(
-        ConfigInterface $config,
+        private ConfigInterface $config,
         DependencyResolverInterface $resolver,
         ?string $namespace = null,
         ?LoggerInterface $logger = null
     ) {
-        $this->config            = $config;
         $this->namespace         = $namespace ? : 'Laminas\Di\Generated';
         $this->factoryGenerator  = new FactoryGenerator($config, $resolver, $this->namespace . '\Factory');
         $this->autoloadGenerator = new AutoloadGenerator($this->namespace);
@@ -113,7 +110,7 @@ private function generateFactoryList(array $factories): void
     {
         $indentation = sprintf("\n%s", str_repeat(' ', self::INDENTATION_SPACES));
         $codeLines   = array_map(
-            fn(string $key, string $value): string =>
+            static fn(string $key, string $value): string =>
                 sprintf('%s => %s,', var_export($key, true), var_export($value, true)),
             array_keys($factories),
             $factories
@@ -154,7 +151,7 @@ private function generateTypeFactory(string $class, array &$factories): void
 
     private function generateAutoload(): void
     {
-        $addFactoryPrefix = fn(string $value): string => 'Factory/' . $value;
+        $addFactoryPrefix = static fn(string $value): string => 'Factory/' . $value;
 
         $classmap = array_map($addFactoryPrefix, $this->factoryGenerator->getClassmap());
 
diff --git a/src/Config.php b/src/Config.php
@@ -249,9 +249,8 @@ public function setAlias(string $name, string $class): self
 
     /**
      * @psalm-assert array|ArrayAccess $options
-     * @param mixed $options
      */
-    private function ensureArrayOrArrayAccess($options): void
+    private function ensureArrayOrArrayAccess(mixed $options): void
     {
         if (! is_array($options) && ! $options instanceof ArrayAccess) {
             throw new Exception\InvalidArgumentException(
diff --git a/src/Container/ConfigFactory.php b/src/Container/ConfigFactory.php
@@ -9,11 +9,11 @@
 use Laminas\Di\ConfigInterface;
 use Laminas\Di\LegacyConfig;
 use Psr\Container\ContainerInterface;
-use Traversable;
 
 use function array_merge_recursive;
 use function assert;
 use function is_array;
+use function is_iterable;
 use function trigger_error;
 
 use const E_USER_DEPRECATED;
@@ -47,7 +47,7 @@ public function create(ContainerInterface $container): ConfigInterface
                 E_USER_DEPRECATED
             );
 
-            assert(is_array($legacyData) || $legacyData instanceof Traversable || $legacyData instanceof ArrayAccess);
+            assert(is_iterable($legacyData) || $legacyData instanceof ArrayAccess);
 
             $legacyConfig = new LegacyConfig($legacyData);
             $data         = array_merge_recursive($legacyConfig->toArray(), $data);
diff --git a/src/LegacyConfig.php b/src/LegacyConfig.php
@@ -15,7 +15,7 @@
 use function is_array;
 use function is_iterable;
 use function is_string;
-use function strpos;
+use function str_contains;
 use function trigger_error;
 
 use const E_USER_DEPRECATED;
@@ -58,7 +58,7 @@ private function prepareParametersArray($parameters): array
         foreach ($parameters as $key => $value) {
             $key = (string) $key;
 
-            if (strpos($key, ':') !== false) {
+            if (str_contains($key, ':')) {
                 trigger_error('Full qualified parameter positions are no longer supported', E_USER_DEPRECATED);
             }
 
diff --git a/src/Resolver/DependencyResolver.php b/src/Resolver/DependencyResolver.php
@@ -107,7 +107,7 @@ private function getConfiguredParameters(string $requestedType): array
 
         // A type configuration may define a parameter should be auto resolved
         // even it was defined earlier
-        $params = array_filter($params, fn($value) => $value !== '*');
+        $params = array_filter($params, static fn($value): bool => $value !== '*');
 
         return $params;
     }
@@ -148,10 +148,7 @@ private function isUsableType(string $type, string $requiredType): bool
             && ($this->container === null || $this->container->has($type));
     }
 
-    /**
-     * @param mixed $value
-     */
-    private function getTypeNameFromValue($value): string
+    private function getTypeNameFromValue(mixed $value): string
     {
         $type = gettype($value);
         return $this->gettypeMap[$type] ?? $type;
@@ -163,7 +160,7 @@ private function getTypeNameFromValue($value): string
      * @param mixed  $value The value to check
      * @param string $type The typename to check against
      */
-    private function isValueOf($value, string $type): bool
+    private function isValueOf(mixed $value, string $type): bool
     {
         if (! $this->isBuiltinType($type)) {
             return $value instanceof $type;
@@ -224,10 +221,8 @@ private function isCallableType(string $type): bool
      * Prepare a candidate for injection
      *
      * If the candidate is usable, its injection representation is returned
-     *
-     * @param mixed $value
      */
-    private function prepareInjection($value, ?string $requiredType): ?InjectionInterface
+    private function prepareInjection(mixed $value, ?string $requiredType): ?InjectionInterface
     {
         if ($value instanceof ValueInjection || $value instanceof TypeInjection) {
             return $value;
diff --git a/src/Resolver/TypeInjection.php b/src/Resolver/TypeInjection.php
@@ -5,6 +5,7 @@
 namespace Laminas\Di\Resolver;
 
 use Psr\Container\ContainerInterface;
+use Stringable;
 
 use function trigger_error;
 use function var_export;
@@ -14,19 +15,17 @@
 /**
  * Wrapper for types that should be looked up for injection
  */
-final class TypeInjection implements InjectionInterface
+final class TypeInjection implements InjectionInterface, Stringable
 {
-    /**
-     * Holds the type name to look up
-     */
-    private string $type;
-
     /**
      * Constructor
      */
-    public function __construct(string $type)
-    {
-        $this->type = $type;
+    public function __construct(
+        /**
+         * Holds the type name to look up
+         */
+        private string $type
+    ) {
     }
 
     public function export(): string
diff --git a/src/Resolver/ValueInjection.php b/src/Resolver/ValueInjection.php
@@ -22,19 +22,12 @@
  */
 class ValueInjection implements InjectionInterface
 {
-    /**
-     * Holds the value to inject
-     *
-     * @var mixed
-     */
-    protected $value;
-
-    /**
-     * @param mixed $value
-     */
-    public function __construct($value)
-    {
-        $this->value = $value;
+    public function __construct(
+        /**
+         * Holds the value to inject
+         */
+        protected mixed $value
+    ) {
     }
 
     public static function __set_state(array $state): self
@@ -71,10 +64,8 @@ public function isExportable(): bool
     /**
      * Check if the provided value is exportable.
      * For arrays it uses recursion.
-     *
-     * @param mixed $value
      */
-    private function isExportableRecursive($value): bool
+    private function isExportableRecursive(mixed $value): bool
     {
         if (is_scalar($value) || $value === null) {
             return true;
diff --git a/test/CodeGenerator/AbstractInjectorTest.php b/test/CodeGenerator/AbstractInjectorTest.php
@@ -176,7 +176,7 @@ public function testConstructionWithoutContainerUsesDefaultContainer(): void
 
     public function testFactoryIsCreatedFromClassNameString(): void
     {
-        $subject = $this->createTestSubject(fn() => ['SomeClass' => StdClassFactory::class]);
+        $subject = $this->createTestSubject(static fn(): array => ['SomeClass' => StdClassFactory::class]);
 
         $factoryInstancesProperty = new ReflectionProperty(AbstractInjector::class, 'factoryInstances');
         $factoriesProperty        = new ReflectionProperty(AbstractInjector::class, 'factories');
diff --git a/test/Container/ConfigFactoryTest.php b/test/Container/ConfigFactoryTest.php
@@ -110,7 +110,7 @@ public function testLegacyConfigIsRespected()
             ],
         ]);
 
-        set_error_handler(function ($errno, $errstr) {
+        set_error_handler(static function ($errno, $errstr) {
             if ($errno !== E_USER_DEPRECATED) {
                 return false;
             }
diff --git a/test/Container/GeneratorFactoryTest.php b/test/Container/GeneratorFactoryTest.php
@@ -36,7 +36,7 @@ public function testInvokeCreatesGenerator(): void
     public function testFactoryUsesDiConfigContainer(): void
     {
         $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
-        $container->method('has')->willReturnCallback(fn($type) => $type === ConfigInterface::class);
+        $container->method('has')->willReturnCallback(static fn($type): bool => $type === ConfigInterface::class);
 
         $container->expects($this->atLeastOnce())
             ->method('get')
diff --git a/test/DefaultContainerTest.php b/test/DefaultContainerTest.php
@@ -94,7 +94,7 @@ public function testGetInstanciatesOnlyOnce(): void
         $injector->expects($this->once())
             ->method('create')
             ->with($key)
-            ->willReturnCallback(fn() => new stdClass());
+            ->willReturnCallback(static fn(): stdClass => new stdClass());
 
         $container = new DefaultContainer($injector);
 
diff --git a/test/Definition/Reflection/ClassDefinitionTest.php b/test/Definition/Reflection/ClassDefinitionTest.php
@@ -158,7 +158,7 @@ public function testRedundantUaSortInClassDefinition(): void
 
         uasort(
             $parameters,
-            static fn (ReflectionParameter $a, ReflectionParameter $b) => $a->getPosition() - $b->getPosition()
+            static fn (ReflectionParameter $a, ReflectionParameter $b): int => $a->getPosition() - $b->getPosition()
         );
 
         self::assertEquals(
diff --git a/test/Definition/Reflection/ParameterTest.php b/test/Definition/Reflection/ParameterTest.php
@@ -35,14 +35,13 @@ public function provideGeneralParameters(): array
 
     /**
      * @dataProvider provideGeneralParameters
-     * @param mixed $expectedDefault
      */
     public function testParamterReflectedCorrectly(
         ReflectionParameter $reflection,
         string $expectedName,
         int $expectedPosition,
         bool $expectRequired,
-        $expectedDefault
+        mixed $expectedDefault
     ) {
         $instance = new Parameter($reflection);
 
diff --git a/test/InjectorTest.php b/test/InjectorTest.php
@@ -30,10 +30,9 @@
 final class InjectorTest extends TestCase
 {
     /**
-     * @param mixed $value
      * @return Constraint\IsIdentical
      */
-    private function isIdentical($value)
+    private function isIdentical(mixed $value)
     {
         return new Constraint\IsIdentical($value);
     }
@@ -194,7 +193,7 @@ public function provideCircularClasses(): array
             'selfOptional' => TestAsset\CircularClasses\Y::class,
         ];
 
-        return array_map(fn($class) => [$class], $classes);
+        return array_map(static fn($class): array => [$class], $classes);
     }
 
     /**
@@ -231,8 +230,8 @@ public function testDeepDependencyUsesContainer(): void
         $container = $this->getMockForAbstractClass(ContainerInterface::class);
 
         // Mocks a container that always creates new instances
-        $container->method('has')->willReturnCallback(fn(string $class) => $injector->canCreate($class));
-        $container->method('get')->willReturnCallback(fn(string $class) => $injector->create($class));
+        $container->method('has')->willReturnCallback(static fn(string $class): bool => $injector->canCreate($class));
+        $container->method('get')->willReturnCallback(static fn(string $class): object => $injector->create($class));
 
         $injector->setContainer($container);
 
@@ -370,9 +369,8 @@ public function provideUnexpectedResolverValues(): array
 
     /**
      * @dataProvider provideUnexpectedResolverValues
-     * @param mixed $unexpectedValue
      */
-    public function testUnexpectedResolverResultThrowsTypeError($unexpectedValue): void
+    public function testUnexpectedResolverResultThrowsTypeError(mixed $unexpectedValue): void
     {
         $resolver = $this->getMockBuilder(DependencyResolverInterface::class)->getMockForAbstractClass();
         $resolver->expects($this->atLeastOnce())
diff --git a/test/Resolver/DependencyResolverTest.php b/test/Resolver/DependencyResolverTest.php
diff --git a/test/Resolver/ValueInjectionTest.php b/test/Resolver/ValueInjectionTest.php

Original file line number	Diff line number	Diff line change
`@@ -26,11 +26,8 @@ class AutoloadGenerator`
`26`	`26`	`private const CLASS_TEMPLATE = __DIR__ . '/../../templates/autoloader-class.template';`
`27`	`27`	`private const FILE_TEMPLATE = __DIR__ . '/../../templates/autoloader-file.template';`
`28`	`28`
`29`		`- private string $namespace;`
`30`		`-`
`31`		`- public function __construct(string $namespace)`
	`29`	`+ public function __construct(private string $namespace)`
`32`	`30`	`{`
`33`		`- $this->namespace = $namespace;`
`34`	`31`	`}`
`35`	`32`
`36`	`33`	`private function writeFile(string $filename, string $code): void`
`@@ -65,7 +62,7 @@ private function buildFromTemplate(string $templateFile, string $outputFile, arr`
`65`	`62`	`private function generateClassmapCode(array &$classmap): string`
`66`	`63`	`{`
`67`	`64`	`$lines = array_map(`
`68`		`- fn(string $class, string $file): string => sprintf(`
	`65`	`+ static fn(string $class, string $file): string => sprintf(`
`69`	`66`	`'%s => %s,',`
`70`	`67`	`var_export($class, true),`
`71`	`68`	`var_export($file, true)`