Format code (#5172)

limingxinleo · web-flow · commit 56c1b1145d74 · 2022-11-01T10:50:54.000+08:00
diff --git a/src/AbstractCallableDefinitionCollector.php b/src/AbstractCallableDefinitionCollector.php
@@ -11,10 +11,14 @@
  */
 namespace Hyperf\Di;
 
+use ReflectionNamedType;
+use ReflectionParameter;
+use ReflectionUnionType;
+
 abstract class AbstractCallableDefinitionCollector extends MetadataCollector
 {
     /**
-     * @param array<\ReflectionParameter> $parameters
+     * @param array<ReflectionParameter> $parameters
      */
     protected function getDefinitionsFromParameters(array $parameters): array
     {
@@ -38,8 +42,8 @@ protected function createType(string $name, ?\ReflectionType $type, bool $allows
     {
         // TODO: Support ReflectionUnionType.
         $typeName = match (true) {
-            $type instanceof \ReflectionNamedType => $type->getName(),
-            $type instanceof \ReflectionUnionType => $type->getTypes()[0]->getName(),
+            $type instanceof ReflectionNamedType => $type->getName(),
+            $type instanceof ReflectionUnionType => $type->getTypes()[0]->getName(),
             default => 'mixed'
         };
         return new ReflectionType($typeName, $allowsNull, [
diff --git a/src/Annotation/AnnotationReader.php b/src/Annotation/AnnotationReader.php
@@ -15,6 +15,7 @@
 use ReflectionClass;
 use ReflectionMethod;
 use ReflectionProperty;
+use Reflector;
 
 /**
  * A reader for docblock annotations.
@@ -79,7 +80,7 @@ public function getMethodAnnotation(ReflectionMethod $method, $annotationName)
         return null;
     }
 
-    public function getAttributes(\Reflector $reflection): array
+    public function getAttributes(Reflector $reflection): array
     {
         $result = [];
         if (! method_exists($reflection, 'getAttributes')) {
diff --git a/src/Annotation/Aspect.php b/src/Annotation/Aspect.php
@@ -12,6 +12,7 @@
 namespace Hyperf\Di\Annotation;
 
 use Attribute;
+use InvalidArgumentException;
 
 #[Attribute(Attribute::TARGET_CLASS)]
 class Aspect extends AbstractAnnotation
@@ -40,7 +41,7 @@ protected function collect(string $className)
         $annotationPriority = $this->priority;
         $propertyPriority = $instancePriority ?: null;
         if (! is_null($annotationPriority) && ! is_null($propertyPriority) && $annotationPriority !== $propertyPriority) {
-            throw new \InvalidArgumentException('Cannot define two difference priority of Aspect.');
+            throw new InvalidArgumentException('Cannot define two difference priority of Aspect.');
         }
         $priority = $annotationPriority ?? $propertyPriority;
         // Save the metadata to AspectCollector
diff --git a/src/Annotation/Inject.php b/src/Annotation/Inject.php
@@ -16,6 +16,7 @@
 use Hyperf\Di\ReflectionManager;
 use Hyperf\Utils\CodeGen\PhpDocReaderManager;
 use PhpDocReader\AnnotationException as DocReaderAnnotationException;
+use Throwable;
 
 #[Attribute(Attribute::TARGET_PROPERTY)]
 class Inject extends AbstractAnnotation
@@ -53,7 +54,7 @@ public function collectProperty(string $className, ?string $target): void
                 throw new AnnotationException($exception->getMessage());
             }
             $this->value = '';
-        } catch (\Throwable $exception) {
+        } catch (Throwable $exception) {
             throw new AnnotationException("The @Inject value is invalid for {$className}->{$target}. Because {$exception->getMessage()}");
         }
     }
diff --git a/src/Aop/AstVisitorRegistry.php b/src/Aop/AstVisitorRegistry.php
@@ -11,6 +11,7 @@
  */
 namespace Hyperf\Di\Aop;
 
+use InvalidArgumentException;
 use SplPriorityQueue;
 
 /**
@@ -28,7 +29,7 @@ public static function __callStatic($name, $arguments)
         if (method_exists($queue, $name)) {
             return $queue->{$name}(...$arguments);
         }
-        throw new \InvalidArgumentException('Invalid method for ' . __CLASS__);
+        throw new InvalidArgumentException('Invalid method for ' . __CLASS__);
     }
 
     public static function insert($value, $priority = 0)
diff --git a/src/Aop/ProceedingJoinPoint.php b/src/Aop/ProceedingJoinPoint.php
@@ -15,6 +15,8 @@
 use Hyperf\Di\Annotation\AnnotationCollector;
 use Hyperf\Di\Exception\Exception;
 use Hyperf\Di\ReflectionManager;
+use ReflectionFunction;
+use ReflectionMethod;
 
 class ProceedingJoinPoint
 {
@@ -78,7 +80,7 @@ public function getArguments()
         });
     }
 
-    public function getReflectMethod(): \ReflectionMethod
+    public function getReflectMethod(): ReflectionMethod
     {
         return ReflectionManager::reflectMethod(
             $this->className,
@@ -88,7 +90,7 @@ public function getReflectMethod(): \ReflectionMethod
 
     public function getInstance(): ?object
     {
-        $ref = new \ReflectionFunction($this->originalMethod);
+        $ref = new ReflectionFunction($this->originalMethod);
 
         return $ref->getClosureThis();
     }
diff --git a/src/Aop/PropertyHandlerTrait.php b/src/Aop/PropertyHandlerTrait.php
@@ -14,6 +14,7 @@
 use Hyperf\Di\Annotation\AnnotationCollector;
 use Hyperf\Di\Definition\PropertyHandlerManager;
 use Hyperf\Di\ReflectionManager;
+use ReflectionClass;
 
 trait PropertyHandlerTrait
 {
@@ -54,7 +55,7 @@ protected function __handlePropertyHandler(string $className)
         }
     }
 
-    protected function __handleTrait(\ReflectionClass $reflectionClass, array $handled, string $className): array
+    protected function __handleTrait(ReflectionClass $reflectionClass, array $handled, string $className): array
     {
         foreach ($reflectionClass->getTraits() ?? [] as $reflectionTrait) {
             if (in_array($reflectionTrait->getName(), [ProxyTrait::class, PropertyHandlerTrait::class])) {
diff --git a/src/Aop/ProxyTrait.php b/src/Aop/ProxyTrait.php
@@ -16,6 +16,7 @@
 use Hyperf\Di\Annotation\AspectCollector;
 use Hyperf\Di\ReflectionManager;
 use Hyperf\Utils\ApplicationContext;
+use SplPriorityQueue;
 
 trait ProxyTrait
 {
@@ -62,7 +63,7 @@ protected static function handleAround(ProceedingJoinPoint $proceedingJoinPoint)
         if (! AspectManager::has($className, $methodName)) {
             AspectManager::set($className, $methodName, []);
             $aspects = array_unique(array_merge(static::getClassesAspects($className, $methodName), static::getAnnotationAspects($className, $methodName)));
-            $queue = new \SplPriorityQueue();
+            $queue = new SplPriorityQueue();
             foreach ($aspects as $aspect) {
                 $queue->insert($aspect, AspectCollector::getPriority($aspect));
             }
diff --git a/src/Aop/RegisterInjectPropertyHandler.php b/src/Aop/RegisterInjectPropertyHandler.php
@@ -16,6 +16,7 @@
 use Hyperf\Di\Exception\NotFoundException;
 use Hyperf\Di\ReflectionManager;
 use Hyperf\Utils\ApplicationContext;
+use Throwable;
 
 class RegisterInjectPropertyHandler
 {
@@ -41,7 +42,7 @@ public static function register()
                     } elseif ($annotation->required) {
                         throw new NotFoundException("No entry or class found for '{$annotation->value}'");
                     }
-                } catch (\Throwable $throwable) {
+                } catch (Throwable $throwable) {
                     if ($annotation->required) {
                         throw $throwable;
                     }
diff --git a/src/ClosureDefinitionCollector.php b/src/ClosureDefinitionCollector.php
@@ -11,31 +11,34 @@
  */
 namespace Hyperf\Di;
 
+use Closure;
+use ReflectionFunction;
+
 class ClosureDefinitionCollector extends AbstractCallableDefinitionCollector implements ClosureDefinitionCollectorInterface
 {
     protected static array $container = [];
 
-    public function getParameters(\Closure $closure): array
+    public function getParameters(Closure $closure): array
     {
         $key = spl_object_hash($closure);
         if (static::has($key)) {
             return static::get($key);
         }
-        $reflectionFunction = new \ReflectionFunction($closure);
+        $reflectionFunction = new ReflectionFunction($closure);
         $parameters = $reflectionFunction->getParameters();
 
         $definitions = $this->getDefinitionsFromParameters($parameters);
         static::set($key, $definitions);
         return $definitions;
     }
 
-    public function getReturnType(\Closure $closure): ReflectionType
+    public function getReturnType(Closure $closure): ReflectionType
     {
         $key = spl_object_hash($closure) . '@return';
         if (static::has($key)) {
             return static::get($key);
         }
-        $returnType = (new \ReflectionFunction($closure))->getReturnType();
+        $returnType = (new ReflectionFunction($closure))->getReturnType();
         $type = $this->createType('', $returnType, $returnType ? $returnType->allowsNull() : true);
         static::set($key, $type);
         return $type;
diff --git a/src/ClosureDefinitionCollectorInterface.php b/src/ClosureDefinitionCollectorInterface.php
@@ -11,12 +11,14 @@
  */
 namespace Hyperf\Di;
 
+use Closure;
+
 interface ClosureDefinitionCollectorInterface
 {
     /**
      * @return ReflectionType[]
      */
-    public function getParameters(\Closure $closure): array;
+    public function getParameters(Closure $closure): array;
 
-    public function getReturnType(\Closure $closure): ReflectionType;
+    public function getReturnType(Closure $closure): ReflectionType;
 }
diff --git a/src/Definition/DefinitionSource.php b/src/Definition/DefinitionSource.php
@@ -13,6 +13,7 @@
 
 use Hyperf\Di\ReflectionManager;
 use ReflectionFunctionAbstract;
+use ReflectionNamedType;
 
 use function class_exists;
 use function interface_exists;
@@ -73,7 +74,7 @@ private function getParametersDefinition(ReflectionFunctionAbstract $constructor
             }
 
             $parameterType = $parameter->getType();
-            if ($parameterType instanceof \ReflectionNamedType && ! $parameterType->isBuiltin()) {
+            if ($parameterType instanceof ReflectionNamedType && ! $parameterType->isBuiltin()) {
                 $parameters[$index] = new Reference($parameterType->getName());
             }
         }
diff --git a/src/Exception/CircularDependencyException.php b/src/Exception/CircularDependencyException.php
@@ -11,7 +11,9 @@
  */
 namespace Hyperf\Di\Exception;
 
-class CircularDependencyException extends \RuntimeException
+use RuntimeException;
+
+class CircularDependencyException extends RuntimeException
 {
     protected array $list = [];
 
diff --git a/tests/Annotation/ScannerTest.php b/tests/Annotation/ScannerTest.php
@@ -27,6 +27,7 @@
 use HyperfTest\Di\Stub\AspectCollector;
 use Mockery;
 use PHPUnit\Framework\TestCase;
+use ReflectionClass;
 
 /**
  * @internal
@@ -56,7 +57,7 @@ public function testGetChangedAspects()
         Composer::setLoader($loader);
 
         $scanner = new Scanner(new ScanConfig(false, '/'), new NullScanHandler());
-        $ref = new \ReflectionClass($scanner);
+        $ref = new ReflectionClass($scanner);
         $property = $ref->getProperty('filesystem');
         $property->setAccessible(true);
         $property->setValue($scanner, $filesystem = Mockery::mock(Filesystem::class . '[lastModified]'));
diff --git a/tests/AnnotationReaderTest.php b/tests/AnnotationReaderTest.php
@@ -17,6 +17,7 @@
 use HyperfTest\Di\Stub\NotFoundAttributeTarget;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
+use Throwable;
 
 /**
  * @internal
@@ -33,7 +34,7 @@ public function testGetNotFoundAttributesOfClass()
         try {
             $annotationReader = new AnnotationReader();
             $annotationReader->getAttributes($reflectionClass);
-        } catch (\Throwable $exception) {
+        } catch (Throwable $exception) {
         } finally {
             $actual = '';
             if (isset($exception)) {
@@ -53,7 +54,7 @@ public function testGetNotFoundAttributesOfMethod()
         try {
             $annotationReader = new AnnotationReader();
             $annotationReader->getAttributes($reflectionMethod);
-        } catch (\Throwable $exception) {
+        } catch (Throwable $exception) {
         } finally {
             $actual = '';
             if (isset($exception)) {
@@ -73,7 +74,7 @@ public function testGetNotFoundAttributesOfProperty()
         try {
             $annotationReader = new AnnotationReader();
             $annotationReader->getAttributes($reflectionProperty);
-        } catch (\Throwable $exception) {
+        } catch (Throwable $exception) {
         } finally {
             $actual = '';
             if (isset($exception)) {
@@ -87,14 +88,14 @@ public function testIgnoreAnnotations()
     {
         $reader = new AnnotationReader(['NotExistAnnotation']);
 
-        $res = $reader->getClassAnnotations(new \ReflectionClass(FooWithNotExistAnnotation::class));
+        $res = $reader->getClassAnnotations(new ReflectionClass(FooWithNotExistAnnotation::class));
 
         $this->assertSame(1, count($res));
         $this->assertInstanceOf(IgnoreDemoAnnotation::class, $res[0]);
 
         $reader = new AnnotationReader(['NotExistAnnotation', IgnoreDemoAnnotation::class]);
 
-        $res = $reader->getClassAnnotations(new \ReflectionClass(FooWithNotExistAnnotation::class));
+        $res = $reader->getClassAnnotations(new ReflectionClass(FooWithNotExistAnnotation::class));
 
         $this->assertSame([], $res);
     }
diff --git a/tests/AnnotationTest.php b/tests/AnnotationTest.php
@@ -17,6 +17,7 @@
 use Hyperf\Di\ScanHandler\NullScanHandler;
 use Mockery;
 use PHPUnit\Framework\TestCase;
+use ReflectionClass;
 
 /**
  * @internal
@@ -32,7 +33,7 @@ protected function tearDown(): void
     public function testScanAnnotationsDirectoryNotExist()
     {
         $scanner = new Scanner(new ScanConfig(false, '/'), new NullScanHandler());
-        $ref = new \ReflectionClass($scanner);
+        $ref = new ReflectionClass($scanner);
         $method = $ref->getMethod('normalizeDir');
         $method->setAccessible(true);
 
@@ -43,7 +44,7 @@ public function testScanAnnotationsDirectoryNotExist()
     public function testScanAnnotationsDirectoryEmpty()
     {
         $scanner = new Scanner(new ScanConfig(false, '/'), new NullScanHandler());
-        $ref = new \ReflectionClass($scanner);
+        $ref = new ReflectionClass($scanner);
         $method = $ref->getMethod('normalizeDir');
         $method->setAccessible(true);
 
diff --git a/tests/ClassLoaderTest.php b/tests/ClassLoaderTest.php
@@ -13,6 +13,7 @@
 
 use Hyperf\Di\ClassLoader;
 use PHPUnit\Framework\TestCase;
+use ReflectionClass;
 
 /**
  * @internal
@@ -28,7 +29,7 @@ public function __construct()
             }
         };
 
-        $ref = new \ReflectionClass($class);
+        $ref = new ReflectionClass($class);
         $method = $ref->getMethod('loadDotenv');
         $method->setAccessible(true);
         $method->invoke($class);
diff --git a/tests/ClosureDefinitionTest.php b/tests/ClosureDefinitionTest.php
diff --git a/tests/Definition/DefinitionSourceTest.php b/tests/Definition/DefinitionSourceTest.php
diff --git a/tests/InjectTest.php b/tests/InjectTest.php
diff --git a/tests/ReflectionTest.php b/tests/ReflectionTest.php

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@`
`15`	`15`	`use ReflectionClass;`
`16`	`16`	`use ReflectionMethod;`
`17`	`17`	`use ReflectionProperty;`
	`18`	`+use Reflector;`
`18`	`19`
`19`	`20`	`/**`
`20`	`21`	`* A reader for docblock annotations.`
`@@ -79,7 +80,7 @@ public function getMethodAnnotation(ReflectionMethod $method, $annotationName)`
`79`	`80`	`return null;`
`80`	`81`	`}`
`81`	`82`
`82`		`- public function getAttributes(\Reflector $reflection): array`
	`83`	`+ public function getAttributes(Reflector $reflection): array`
`83`	`84`	`{`
`84`	`85`	`$result = [];`
`85`	`86`	`if (! method_exists($reflection, 'getAttributes')) {`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@`
`16`	`16`	`use Hyperf\Di\ReflectionManager;`
`17`	`17`	`use Hyperf\Utils\CodeGen\PhpDocReaderManager;`
`18`	`18`	`use PhpDocReader\AnnotationException as DocReaderAnnotationException;`
	`19`	`+use Throwable;`
`19`	`20`
`20`	`21`	`#[Attribute(Attribute::TARGET_PROPERTY)]`
`21`	`22`	`class Inject extends AbstractAnnotation`
`@@ -53,7 +54,7 @@ public function collectProperty(string $className, ?string $target): void`
`53`	`54`	`throw new AnnotationException($exception->getMessage());`
`54`	`55`	`}`
`55`	`56`	`$this->value = '';`
`56`		`- } catch (\Throwable $exception) {`
	`57`	`+ } catch (Throwable $exception) {`
`57`	`58`	`throw new AnnotationException("The @Inject value is invalid for {$className}->{$target}. Because {$exception->getMessage()}");`
`58`	`59`	`}`
`59`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`	`*/`
`12`	`12`	`namespace Hyperf\Di\Aop;`
`13`	`13`
	`14`	`+use InvalidArgumentException;`
`14`	`15`	`use SplPriorityQueue;`
`15`	`16`
`16`	`17`	`/**`
`@@ -28,7 +29,7 @@ public static function __callStatic($name, $arguments)`
`28`	`29`	`if (method_exists($queue, $name)) {`
`29`	`30`	`return $queue->{$name}(...$arguments);`
`30`	`31`	`}`
`31`		`- throw new \InvalidArgumentException('Invalid method for ' . __CLASS__);`
	`32`	`+ throw new InvalidArgumentException('Invalid method for ' . __CLASS__);`
`32`	`33`	`}`
`33`	`34`
`34`	`35`	`public static function insert($value, $priority = 0)`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,8 @@`
`15`	`15`	`use Hyperf\Di\Annotation\AnnotationCollector;`
`16`	`16`	`use Hyperf\Di\Exception\Exception;`
`17`	`17`	`use Hyperf\Di\ReflectionManager;`
	`18`	`+use ReflectionFunction;`
	`19`	`+use ReflectionMethod;`
`18`	`20`
`19`	`21`	`class ProceedingJoinPoint`
`20`	`22`	`{`
`@@ -78,7 +80,7 @@ public function getArguments()`
`78`	`80`	`});`
`79`	`81`	`}`
`80`	`82`
`81`		`- public function getReflectMethod(): \ReflectionMethod`
	`83`	`+ public function getReflectMethod(): ReflectionMethod`
`82`	`84`	`{`
`83`	`85`	`return ReflectionManager::reflectMethod(`
`84`	`86`	`$this->className,`
`@@ -88,7 +90,7 @@ public function getReflectMethod(): \ReflectionMethod`
`88`	`90`
`89`	`91`	`public function getInstance(): ?object`
`90`	`92`	`{`
`91`		`- $ref = new \ReflectionFunction($this->originalMethod);`
	`93`	`+ $ref = new ReflectionFunction($this->originalMethod);`
`92`	`94`
`93`	`95`	`return $ref->getClosureThis();`
`94`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`use Hyperf\Di\Annotation\AnnotationCollector;`
`15`	`15`	`use Hyperf\Di\Definition\PropertyHandlerManager;`
`16`	`16`	`use Hyperf\Di\ReflectionManager;`
	`17`	`+use ReflectionClass;`
`17`	`18`
`18`	`19`	`trait PropertyHandlerTrait`
`19`	`20`	`{`
`@@ -54,7 +55,7 @@ protected function __handlePropertyHandler(string $className)`
`54`	`55`	`}`
`55`	`56`	`}`
`56`	`57`
`57`		`- protected function __handleTrait(\ReflectionClass $reflectionClass, array $handled, string $className): array`
	`58`	`+ protected function __handleTrait(ReflectionClass $reflectionClass, array $handled, string $className): array`
`58`	`59`	`{`
`59`	`60`	`foreach ($reflectionClass->getTraits() ?? [] as $reflectionTrait) {`
`60`	`61`	`if (in_array($reflectionTrait->getName(), [ProxyTrait::class, PropertyHandlerTrait::class])) {`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@`
`13`	`13`
`14`	`14`	`use Hyperf\Di\ReflectionManager;`
`15`	`15`	`use ReflectionFunctionAbstract;`
	`16`	`+use ReflectionNamedType;`
`16`	`17`
`17`	`18`	`use function class_exists;`
`18`	`19`	`use function interface_exists;`
`@@ -73,7 +74,7 @@ private function getParametersDefinition(ReflectionFunctionAbstract $constructor`
`73`	`74`	`}`
`74`	`75`
`75`	`76`	`$parameterType = $parameter->getType();`
`76`		`- if ($parameterType instanceof \ReflectionNamedType && ! $parameterType->isBuiltin()) {`
	`77`	`+ if ($parameterType instanceof ReflectionNamedType && ! $parameterType->isBuiltin()) {`
`77`	`78`	`$parameters[$index] = new Reference($parameterType->getName());`
`78`	`79`	`}`
`79`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,9 @@`
`11`	`11`	`*/`
`12`	`12`	`namespace Hyperf\Di\Exception;`
`13`	`13`
`14`		`-class CircularDependencyException extends \RuntimeException`
	`14`	`+use RuntimeException;`
	`15`	`+`
	`16`	`+class CircularDependencyException extends RuntimeException`
`15`	`17`	`{`
`16`	`18`	`protected array $list = [];`
`17`	`19`