Merge pull request #718 from samsonasik/update-php-up-to-php8

Ocramius · web-flow · commit 0a73ac7cd861 · 2021-10-12T18:48:29.000+02:00
Update to PHP 8.0+ syntax in `src/`, where viable
diff --git a/src/ProxyManager/Autoloader/Autoloader.php b/src/ProxyManager/Autoloader/Autoloader.php
@@ -12,13 +12,8 @@
 
 class Autoloader implements AutoloaderInterface
 {
-    protected FileLocatorInterface $fileLocator;
-    protected ClassNameInflectorInterface $classNameInflector;
-
-    public function __construct(FileLocatorInterface $fileLocator, ClassNameInflectorInterface $classNameInflector)
+    public function __construct(protected FileLocatorInterface $fileLocator, protected ClassNameInflectorInterface $classNameInflector)
     {
-        $this->fileLocator        = $fileLocator;
-        $this->classNameInflector = $classNameInflector;
     }
 
     public function __invoke(string $className): bool
diff --git a/src/ProxyManager/Exception/InvalidProxiedClassException.php b/src/ProxyManager/Exception/InvalidProxiedClassException.php
@@ -36,14 +36,10 @@ public static function abstractProtectedMethodsNotSupported(ReflectionClass $ref
             implode(
                 "\n",
                 array_map(
-                    static function (ReflectionMethod $reflectionMethod): string {
-                        return $reflectionMethod->getDeclaringClass()->getName() . '::' . $reflectionMethod->getName();
-                    },
+                    static fn (ReflectionMethod $reflectionMethod): string => $reflectionMethod->getDeclaringClass()->getName() . '::' . $reflectionMethod->getName(),
                     array_filter(
                         $reflection->getMethods(),
-                        static function (ReflectionMethod $method): bool {
-                            return $method->isAbstract() && $method->isProtected();
-                        }
+                        static fn (ReflectionMethod $method): bool => $method->isAbstract() && $method->isProtected()
                     )
                 )
             )
diff --git a/src/ProxyManager/Exception/UnsupportedProxiedClassException.php b/src/ProxyManager/Exception/UnsupportedProxiedClassException.php
@@ -36,9 +36,7 @@ public static function nonReferenceableLocalizedReflectionProperties(
         return new self(sprintf(
             'Cannot create references for following properties of class %s: %s',
             $class->getName(),
-            implode(', ', array_map(static function (ReflectionProperty $property): string {
-                return $property->getName();
-            }, $properties->getInstanceProperties()))
+            implode(', ', array_map(static fn (ReflectionProperty $property): string => $property->getName(), $properties->getInstanceProperties()))
         ));
     }
 }
diff --git a/src/ProxyManager/Factory/AccessInterceptorScopeLocalizerFactory.php b/src/ProxyManager/Factory/AccessInterceptorScopeLocalizerFactory.php
@@ -13,8 +13,6 @@
 use ProxyManager\Signature\Exception\InvalidSignatureException;
 use ProxyManager\Signature\Exception\MissingSignatureException;
 
-use function get_class;
-
 /**
  * Factory responsible of producing proxy objects
  */
@@ -67,7 +65,7 @@ public function createProxy(
         array $prefixInterceptors = [],
         array $suffixInterceptors = []
     ): AccessInterceptorInterface {
-        $proxyClassName = $this->generateProxy(get_class($instance));
+        $proxyClassName = $this->generateProxy($instance::class);
 
         /**
          * We ignore type checks here, since `staticProxyConstructor` is not interfaced (by design)
diff --git a/src/ProxyManager/Factory/AccessInterceptorValueHolderFactory.php b/src/ProxyManager/Factory/AccessInterceptorValueHolderFactory.php
@@ -15,8 +15,6 @@
 use ProxyManager\Signature\Exception\InvalidSignatureException;
 use ProxyManager\Signature\Exception\MissingSignatureException;
 
-use function get_class;
-
 /**
  * Factory responsible of producing proxy objects
  */
@@ -69,7 +67,7 @@ public function createProxy(
         array $prefixInterceptors = [],
         array $suffixInterceptors = []
     ): AccessInterceptorValueHolderInterface {
-        $proxyClassName = $this->generateProxy(get_class($instance));
+        $proxyClassName = $this->generateProxy($instance::class);
 
         /**
          * We ignore type checks here, since `staticProxyConstructor` is not interfaced (by design)
diff --git a/src/ProxyManager/Factory/NullObjectFactory.php b/src/ProxyManager/Factory/NullObjectFactory.php
@@ -12,7 +12,6 @@
 use ProxyManager\Signature\Exception\InvalidSignatureException;
 use ProxyManager\Signature\Exception\MissingSignatureException;
 
-use function get_class;
 use function is_object;
 
 /**
@@ -45,7 +44,7 @@ public function __construct(?Configuration $configuration = null)
      */
     public function createProxy(object|string $instanceOrClassName): NullObjectInterface
     {
-        $className      = is_object($instanceOrClassName) ? get_class($instanceOrClassName) : $instanceOrClassName;
+        $className      = is_object($instanceOrClassName) ? $instanceOrClassName::class : $instanceOrClassName;
         $proxyClassName = $this->generateProxy($className);
 
         /**
diff --git a/src/ProxyManager/Factory/RemoteObject/Adapter/BaseAdapter.php b/src/ProxyManager/Factory/RemoteObject/Adapter/BaseAdapter.php
@@ -14,24 +14,16 @@
  */
 abstract class BaseAdapter implements AdapterInterface
 {
-    protected Client $client;
-
-    /**
-     * Service name mapping
-     *
-     * @var array<string, string>
-     */
-    protected array $map = [];
-
     /**
      * Constructor
      *
      * @param array<string, string> $map map of service names to their aliases
      */
-    public function __construct(Client $client, array $map = [])
-    {
-        $this->client = $client;
-        $this->map    = $map;
+    public function __construct(
+        protected Client $client,
+        // Service name mapping
+        protected array $map = []
+    ) {
     }
 
     /**
diff --git a/src/ProxyManager/Factory/RemoteObjectFactory.php b/src/ProxyManager/Factory/RemoteObjectFactory.php
@@ -13,28 +13,23 @@
 use ProxyManager\Signature\Exception\InvalidSignatureException;
 use ProxyManager\Signature\Exception\MissingSignatureException;
 
-use function get_class;
 use function is_object;
 
 /**
  * Factory responsible of producing remote proxy objects
  */
 class RemoteObjectFactory extends AbstractBaseFactory
 {
-    protected AdapterInterface $adapter;
     private ?RemoteObjectGenerator $generator;
 
     /**
      * {@inheritDoc}
      *
-     * @param AdapterInterface $adapter
-     * @param Configuration    $configuration
+     * @param Configuration $configuration
      */
-    public function __construct(AdapterInterface $adapter, ?Configuration $configuration = null)
+    public function __construct(protected AdapterInterface $adapter, ?Configuration $configuration = null)
     {
         parent::__construct($configuration);
-
-        $this->adapter   = $adapter;
         $this->generator = new RemoteObjectGenerator();
     }
 
@@ -54,7 +49,7 @@ public function __construct(AdapterInterface $adapter, ?Configuration $configura
     public function createProxy(string|object $instanceOrClassName): RemoteObjectInterface
     {
         $proxyClassName = $this->generateProxy(
-            is_object($instanceOrClassName) ? get_class($instanceOrClassName) : $instanceOrClassName
+            is_object($instanceOrClassName) ? $instanceOrClassName::class : $instanceOrClassName
         );
 
         /**
diff --git a/src/ProxyManager/GeneratorStrategy/FileWriterGeneratorStrategy.php b/src/ProxyManager/GeneratorStrategy/FileWriterGeneratorStrategy.php
@@ -21,12 +21,10 @@
  */
 class FileWriterGeneratorStrategy implements GeneratorStrategyInterface
 {
-    protected FileLocatorInterface $fileLocator;
     private Closure $emptyErrorHandler;
 
-    public function __construct(FileLocatorInterface $fileLocator)
+    public function __construct(protected FileLocatorInterface $fileLocator)
     {
-        $this->fileLocator       = $fileLocator;
         $this->emptyErrorHandler = static function (): void {
         };
     }
diff --git a/src/ProxyManager/Inflector/ClassNameInflector.php b/src/ProxyManager/Inflector/ClassNameInflector.php
@@ -14,15 +14,13 @@
 
 final class ClassNameInflector implements ClassNameInflectorInterface
 {
-    protected string $proxyNamespace;
     /** @var int @TODO annotation still needed for phpstan to understand this */
     private int $proxyMarkerLength;
     private string $proxyMarker;
     private ParameterHasher $parameterHasher;
 
-    public function __construct(string $proxyNamespace)
+    public function __construct(protected string $proxyNamespace)
     {
-        $this->proxyNamespace    = $proxyNamespace;
         $this->proxyMarker       = '\\' . self::PROXY_MARKER . '\\';
         $this->proxyMarkerLength = strlen($this->proxyMarker);
         $this->parameterHasher   = new ParameterHasher();
diff --git a/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/Util/InterceptorGenerator.php b/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/Util/InterceptorGenerator.php
@@ -67,9 +67,7 @@ public static function createInterceptedMethodBody(
             '{{$suffixInterceptorsName}}'      => $suffixInterceptors->getName(),
             '{{$suffixEarlyReturnExpression}}' => ProxiedMethodReturnExpression::generate('$suffixReturnValue', $originalMethod),
             '{{$returnExpression}}'            => ProxiedMethodReturnExpression::generate('$returnValue', $originalMethod),
-            '{{$paramsString}}'                => 'array(' . implode(', ', array_map(static function (ParameterGenerator $parameter): string {
-                return var_export($parameter->getName(), true) . ' => $' . $parameter->getName();
-            }, $method->getParameters())) . ')',
+            '{{$paramsString}}'                => 'array(' . implode(', ', array_map(static fn (ParameterGenerator $parameter): string => var_export($parameter->getName(), true) . ' => $' . $parameter->getName(), $method->getParameters())) . ')',
         ];
 
         return str_replace(
diff --git a/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizerGenerator.php b/src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizerGenerator.php
@@ -89,12 +89,10 @@ private function buildMethodInterceptor(
         MethodPrefixInterceptors $prefixInterceptors,
         MethodSuffixInterceptors $suffixInterceptors
     ): callable {
-        return static function (ReflectionMethod $method) use ($prefixInterceptors, $suffixInterceptors): InterceptedMethod {
-            return InterceptedMethod::generateMethod(
-                new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
-                $prefixInterceptors,
-                $suffixInterceptors
-            );
-        };
+        return static fn (ReflectionMethod $method): InterceptedMethod => InterceptedMethod::generateMethod(
+            new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
+            $prefixInterceptors,
+            $suffixInterceptors
+        );
     }
 }
diff --git a/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolderGenerator.php b/src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolderGenerator.php
@@ -128,13 +128,11 @@ private function buildMethodInterceptor(
         MethodSuffixInterceptors $suffixes,
         ValueHolderProperty $valueHolder
     ): callable {
-        return static function (ReflectionMethod $method) use ($prefixes, $suffixes, $valueHolder): InterceptedMethod {
-            return InterceptedMethod::generateMethod(
-                new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
-                $valueHolder,
-                $prefixes,
-                $suffixes
-            );
-        };
+        return static fn (ReflectionMethod $method): InterceptedMethod => InterceptedMethod::generateMethod(
+            new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
+            $valueHolder,
+            $prefixes,
+            $suffixes
+        );
     }
 }
diff --git a/src/ProxyManager/ProxyGenerator/Assertion/CanProxyAssertion.php b/src/ProxyManager/ProxyGenerator/Assertion/CanProxyAssertion.php
@@ -58,9 +58,7 @@ private static function hasNoAbstractProtectedMethods(ReflectionClass $originalC
     {
         $protectedAbstract = array_filter(
             $originalClass->getMethods(),
-            static function (ReflectionMethod $method): bool {
-                return $method->isAbstract() && $method->isProtected();
-            }
+            static fn (ReflectionMethod $method): bool => $method->isAbstract() && $method->isProtected()
         );
 
         if ($protectedAbstract) {
diff --git a/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/CallInitializer.php b/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/CallInitializer.php
@@ -113,10 +113,8 @@ private function getPropertyDefaultsAssignments(array $properties): string
         return implode(
             "\n",
             array_map(
-                function (ReflectionProperty $property): string {
-                    return '    $instance->' . $property->getName()
-                        . ' = ' . $this->getExportedPropertyDefaultValue($property) . ';';
-                },
+                fn (ReflectionProperty $property): string => '    $instance->' . $property->getName()
+                    . ' = ' . $this->getExportedPropertyDefaultValue($property) . ';',
                 $properties
             )
         );
diff --git a/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/SetProxyInitializer.php b/src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator/SetProxyInitializer.php
@@ -4,6 +4,7 @@
 
 namespace ProxyManager\ProxyGenerator\LazyLoadingGhost\MethodGenerator;
 
+use Closure;
 use Laminas\Code\Generator\ParameterGenerator;
 use Laminas\Code\Generator\PropertyGenerator;
 use ProxyManager\Generator\MethodGenerator;
@@ -21,7 +22,7 @@ public function __construct(PropertyGenerator $initializerProperty)
     {
         parent::__construct(
             'setProxyInitializer',
-            [(new ParameterGenerator('initializer', 'Closure'))->setDefaultValue(null)],
+            [(new ParameterGenerator('initializer', Closure::class))->setDefaultValue(null)],
             self::FLAG_PUBLIC,
             '$this->' . $initializerProperty->getName() . ' = $initializer;'
         );
diff --git a/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolderGenerator.php b/src/ProxyManager/ProxyGenerator/LazyLoadingValueHolderGenerator.php
@@ -104,12 +104,10 @@ private function buildLazyLoadingMethodInterceptor(
         InitializerProperty $initializer,
         ValueHolderProperty $valueHolder
     ): callable {
-        return static function (ReflectionMethod $method) use ($initializer, $valueHolder): LazyLoadingMethodInterceptor {
-            return LazyLoadingMethodInterceptor::generateMethod(
-                new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
-                $initializer,
-                $valueHolder
-            );
-        };
+        return static fn (ReflectionMethod $method): LazyLoadingMethodInterceptor => LazyLoadingMethodInterceptor::generateMethod(
+            new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
+            $initializer,
+            $valueHolder
+        );
     }
 }
diff --git a/src/ProxyManager/ProxyGenerator/NullObject/MethodGenerator/StaticProxyConstructor.php b/src/ProxyManager/ProxyGenerator/NullObject/MethodGenerator/StaticProxyConstructor.php
@@ -30,9 +30,7 @@ public function __construct(ReflectionClass $originalClass)
         parent::__construct('staticProxyConstructor', [], self::FLAG_PUBLIC | self::FLAG_STATIC);
 
         $nullableProperties = array_map(
-            static function (ReflectionProperty $publicProperty): string {
-                return '$instance->' . $publicProperty->getName() . ' = null;';
-            },
+            static fn (ReflectionProperty $publicProperty): string => '$instance->' . $publicProperty->getName() . ' = null;',
             Properties::fromReflectionClass($originalClass)
                 ->onlyNullableProperties()
                 ->getPublicProperties()
diff --git a/src/ProxyManager/ProxyGenerator/RemoteObjectGenerator.php b/src/ProxyManager/ProxyGenerator/RemoteObjectGenerator.php
@@ -62,13 +62,11 @@ static function (MethodGenerator $generatedMethod) use ($originalClass, $classGe
             },
             array_merge(
                 array_map(
-                    static function (ReflectionMethod $method) use ($adapter, $originalClass): RemoteObjectMethod {
-                        return RemoteObjectMethod::generateMethod(
-                            new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
-                            $adapter,
-                            $originalClass
-                        );
-                    },
+                    static fn (ReflectionMethod $method): RemoteObjectMethod => RemoteObjectMethod::generateMethod(
+                        new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
+                        $adapter,
+                        $originalClass
+                    ),
                     ProxiedMethodsFilter::getProxiedMethods(
                         $originalClass,
                         ['__get', '__set', '__isset', '__unset']
diff --git a/src/ProxyManager/ProxyGenerator/Util/Properties.php b/src/ProxyManager/ProxyGenerator/Util/Properties.php
@@ -23,15 +23,11 @@
  */
 final class Properties
 {
-    /** @var ReflectionProperty[] */
-    private array $properties;
-
     /**
      * @param ReflectionProperty[] $properties
      */
-    private function __construct(array $properties)
+    private function __construct(private array $properties)
     {
-        $this->properties = $properties;
     }
 
     public static function fromReflectionClass(ReflectionClass $reflection): self
@@ -46,15 +42,11 @@ public static function fromReflectionClass(ReflectionClass $reflection): self
         } while ($class);
 
         return new self(array_merge(
-            ...array_map(static function (ReflectionClass $class): array {
-                return array_values(array_filter(
-                    $class->getProperties(),
-                    static function (ReflectionProperty $property) use ($class): bool {
-                        return $class->getName() === $property->getDeclaringClass()->getName()
-                            && ! $property->isStatic();
-                    }
-                ));
-            }, $parentClasses)
+            ...array_map(static fn (ReflectionClass $class): array => array_values(array_filter(
+                $class->getProperties(),
+                static fn (ReflectionProperty $property): bool => $class->getName() === $property->getDeclaringClass()->getName()
+                    && ! $property->isStatic()
+            )), $parentClasses)
         ));
     }
 
diff --git a/src/ProxyManager/ProxyGenerator/Util/ProxiedMethodsFilter.php b/src/ProxyManager/ProxyGenerator/Util/ProxiedMethodsFilter.php
@@ -63,12 +63,10 @@ private static function doFilter(ReflectionClass $class, array $excluded, bool $
 
         return array_values(array_filter(
             $class->getMethods(ReflectionMethod::IS_PUBLIC),
-            static function (ReflectionMethod $method) use ($ignored, $requireAbstract): bool {
-                return (! $requireAbstract || $method->isAbstract()) && ! (
-                    array_key_exists(strtolower($method->getName()), $ignored)
-                    || self::methodCannotBeProxied($method)
-                );
-            }
+            static fn (ReflectionMethod $method): bool => (! $requireAbstract || $method->isAbstract()) && ! (
+                array_key_exists(strtolower($method->getName()), $ignored)
+                || self::methodCannotBeProxied($method)
+            )
         ));
     }
 
diff --git a/src/ProxyManager/ProxyGenerator/Util/UnsetPropertiesGenerator.php b/src/ProxyManager/ProxyGenerator/Util/UnsetPropertiesGenerator.php
diff --git a/src/ProxyManager/ProxyGenerator/ValueHolder/MethodGenerator/Constructor.php b/src/ProxyManager/ProxyGenerator/ValueHolder/MethodGenerator/Constructor.php
diff --git a/src/ProxyManager/Signature/ClassSignatureGenerator.php b/src/ProxyManager/Signature/ClassSignatureGenerator.php
diff --git a/src/ProxyManager/Signature/SignatureChecker.php b/src/ProxyManager/Signature/SignatureChecker.php

Original file line number	Diff line number	Diff line change
`@@ -12,13 +12,8 @@`
`12`	`12`
`13`	`13`	`class Autoloader implements AutoloaderInterface`
`14`	`14`	`{`
`15`		`- protected FileLocatorInterface $fileLocator;`
`16`		`- protected ClassNameInflectorInterface $classNameInflector;`
`17`		`-`
`18`		`- public function __construct(FileLocatorInterface $fileLocator, ClassNameInflectorInterface $classNameInflector)`
	`15`	`+ public function __construct(protected FileLocatorInterface $fileLocator, protected ClassNameInflectorInterface $classNameInflector)`
`19`	`16`	`{`
`20`		`- $this->fileLocator = $fileLocator;`
`21`		`- $this->classNameInflector = $classNameInflector;`
`22`	`17`	`}`
`23`	`18`
`24`	`19`	`public function __invoke(string $className): bool`
Original file line number	Diff line number	Diff line change
`@@ -36,14 +36,10 @@ public static function abstractProtectedMethodsNotSupported(ReflectionClass $ref`
`36`	`36`	`implode(`
`37`	`37`	`"\n",`
`38`	`38`	`array_map(`
`39`		`- static function (ReflectionMethod $reflectionMethod): string {`
`40`		`- return $reflectionMethod->getDeclaringClass()->getName() . '::' . $reflectionMethod->getName();`
`41`		`- },`
	`39`	`+ static fn (ReflectionMethod $reflectionMethod): string => $reflectionMethod->getDeclaringClass()->getName() . '::' . $reflectionMethod->getName(),`
`42`	`40`	`array_filter(`
`43`	`41`	`$reflection->getMethods(),`
`44`		`- static function (ReflectionMethod $method): bool {`
`45`		`- return $method->isAbstract() && $method->isProtected();`
`46`		`- }`
	`42`	`+ static fn (ReflectionMethod $method): bool => $method->isAbstract() && $method->isProtected()`
`47`	`43`	`)`
`48`	`44`	`)`
`49`	`45`	`)`
Original file line number	Diff line number	Diff line change
`@@ -36,9 +36,7 @@ public static function nonReferenceableLocalizedReflectionProperties(`
`36`	`36`	`return new self(sprintf(`
`37`	`37`	`'Cannot create references for following properties of class %s: %s',`
`38`	`38`	`$class->getName(),`
`39`		`- implode(', ', array_map(static function (ReflectionProperty $property): string {`
`40`		`- return $property->getName();`
`41`		`- }, $properties->getInstanceProperties()))`
	`39`	`+ implode(', ', array_map(static fn (ReflectionProperty $property): string => $property->getName(), $properties->getInstanceProperties()))`
`42`	`40`	`));`
`43`	`41`	`}`
`44`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,10 @@`
`21`	`21`	`*/`
`22`	`22`	`class FileWriterGeneratorStrategy implements GeneratorStrategyInterface`
`23`	`23`	`{`
`24`		`- protected FileLocatorInterface $fileLocator;`
`25`	`24`	`private Closure $emptyErrorHandler;`
`26`	`25`
`27`		`- public function __construct(FileLocatorInterface $fileLocator)`
	`26`	`+ public function __construct(protected FileLocatorInterface $fileLocator)`
`28`	`27`	`{`
`29`		`- $this->fileLocator = $fileLocator;`
`30`	`28`	`$this->emptyErrorHandler = static function (): void {`
`31`	`29`	`};`
`32`	`30`	`}`