chore: refacto extractor (#9)

mtarld · web-flow · commit 4d76ddec725f · 2023-01-07T20:07:23.000+01:00
diff --git a/Exception/MissingTypeException.php b/Exception/MissingTypeException.php
@@ -24,8 +24,6 @@ public static function createForProperty(\ReflectionProperty $property): self
         return new self(sprintf('%s::$%s', $property->getDeclaringClass()->getName(), $property->getName()), 'property');
     }
 
-    // TODO ReturnType -> FunctionReturn
-
     public static function createForFunctionReturn(\ReflectionFunctionAbstract $function): self
     {
         /** @var \ReflectionClass<object>|null $declaringClass */
diff --git a/Hook/Marshal/PropertyHook.php b/Hook/Marshal/PropertyHook.php
@@ -67,7 +67,7 @@ private function name(\ReflectionProperty $property, string $propertyIdentifier,
     private function type(\ReflectionProperty $property, ?\ReflectionFunction $propertyFormatter, array $context): string
     {
         return null !== $propertyFormatter
-            ? $this->typeExtractor->extractFromReturnType($propertyFormatter)
+            ? $this->typeExtractor->extractFromFunctionReturn($propertyFormatter)
             : $this->typeExtractor->extractFromProperty($property);
     }
 
diff --git a/Hook/Marshal/TypeHook.php b/Hook/Marshal/TypeHook.php
@@ -48,7 +48,7 @@ private function type(string $type, ?\ReflectionFunction $typeFormatter, array $
         $currentPropertyClass = $context['symfony']['marshal']['current_property_class'] ?? null;
 
         if (null !== $typeFormatter) {
-            $type = $this->typeExtractor->extractFromReturnType($typeFormatter);
+            $type = $this->typeExtractor->extractFromFunctionReturn($typeFormatter);
 
             // if method doesn't belong to the current class, ignore generic search
             if ($typeFormatter->getClosureScopeClass()?->getName() !== $currentPropertyClass) {
diff --git a/Hook/Unmarshal/PropertyHook.php b/Hook/Unmarshal/PropertyHook.php
@@ -39,7 +39,7 @@ public function __invoke(\ReflectionClass $class, object $object, string $key, c
             $propertyFormatterReflection = new \ReflectionFunction($propertyFormatter);
             $this->validateFormatter($propertyFormatterReflection, $propertyIdentifier);
 
-            $valueType = $this->typeExtractor->extractFromParameter($propertyFormatterReflection->getParameters()[0]);
+            $valueType = $this->typeExtractor->extractFromFunctionParameter($propertyFormatterReflection->getParameters()[0]);
         }
 
         $valueType ??= $this->typeExtractor->extractFromProperty(new \ReflectionProperty($object, $propertyName));
diff --git a/Internal/Parser/Parser.php b/Internal/Parser/Parser.php
@@ -180,8 +180,6 @@ private function instantiateObject(\ReflectionClass $reflection): object
                 continue;
             }
 
-            // TODO throw or collect depending on context (like in AbstractNormalizer)
-
             return $reflection->newInstanceWithoutConstructor();
         }
 
diff --git a/README.md b/README.md
@@ -13,9 +13,9 @@
 - tests (unmarshal from component)
 - create dedicated exceptions and wrap native ones
 - try catch property assignment (to not have TypeError)
+- same for object construction (like in serializer)
 - collect errors mode (optional) -> throw at the end with errors and decoded
   object
-- not internal exceptions (move it to public folder)
 - bench in CI
 
 ## Questions
diff --git a/Tests/Hook/Marshal/PropertyHookTest.php b/Tests/Hook/Marshal/PropertyHookTest.php
@@ -59,7 +59,7 @@ public function testUpdateTypeAccessorAndContextFromFormatter(string $expectedTy
     {
         $typeExtractor = $this->createStub(TypeExtractorInterface::class);
         $typeExtractor->method('extractFromProperty')->willReturn('int');
-        $typeExtractor->method('extractFromReturnType')->willReturn('string');
+        $typeExtractor->method('extractFromFunctionReturn')->willReturn('string');
 
         $context = [
             'symfony' => [
diff --git a/Tests/Hook/Marshal/TypeHookTest.php b/Tests/Hook/Marshal/TypeHookTest.php
@@ -26,7 +26,7 @@ final class TypeHookTest extends TestCase
     public function testUpdateTypeAndAccessorFromFormatter(string $expectedType, string $expectedAccessor, string $formatterReturnType, array $typeFormatters): void
     {
         $typeExtractor = $this->createStub(TypeExtractorInterface::class);
-        $typeExtractor->method('extractFromReturnType')->willReturn($formatterReturnType);
+        $typeExtractor->method('extractFromFunctionReturn')->willReturn($formatterReturnType);
 
         $context = [
             'symfony' => [
@@ -74,7 +74,7 @@ public function testConvertGenericTypes(): void
     public function testDoNotConvertGenericTypesWhenFormatterDoesNotBelongToCurrentClass(): void
     {
         $typeExtractor = $this->createStub(TypeExtractorInterface::class);
-        $typeExtractor->method('extractFromReturnType')->willReturn('T');
+        $typeExtractor->method('extractFromFunctionReturn')->willReturn('T');
 
         $context = [
             'symfony' => [
diff --git a/Tests/Hook/Unmarshal/PropertyHookTest.php b/Tests/Hook/Unmarshal/PropertyHookTest.php
@@ -68,7 +68,7 @@ public function testRetrieveActualPropertyName(): void
     public function testFormatValue(): void
     {
         $typeExtractor = $this->createStub(TypeExtractorInterface::class);
-        $typeExtractor->method('extractFromParameter')->willReturn('string');
+        $typeExtractor->method('extractFromFunctionParameter')->willReturn('string');
 
         $object = new class() {
             public string $foo;
diff --git a/Tests/Type/PhpstanTypeExtractorTest.php b/Tests/Type/PhpstanTypeExtractorTest.php
@@ -59,35 +59,35 @@ public function testCannotHandleUnknownNode(): void
     /**
      * @dataProvider typesDataProvider
      */
-    public function testExtractFromReturnType(string $expectedType, string $method): void
+    public function testExtractFromFunctionReturn(string $expectedType, string $method): void
     {
         $fallbackExtractor = $this->createStub(TypeExtractorInterface::class);
-        $fallbackExtractor->method('extractFromReturnType')->willReturn('FALLBACK');
+        $fallbackExtractor->method('extractFromFunctionReturn')->willReturn('FALLBACK');
 
         $extractor = new PhpstanTypeExtractor($fallbackExtractor);
         $reflectionMethod = (new \ReflectionClass(PhpstanExtractableDummy::class))->getMethod($method);
 
-        $this->assertSame($expectedType, $extractor->extractFromReturnType($reflectionMethod));
+        $this->assertSame($expectedType, $extractor->extractFromFunctionReturn($reflectionMethod));
     }
 
-    public function testFallbackOnVoidAndNeverReturnType(): void
+    public function testFallbackOnVoidAndNeverFunctionReturn(): void
     {
         $fallbackExtractor = $this->createStub(TypeExtractorInterface::class);
-        $fallbackExtractor->method('extractFromReturnType')->willReturn('FALLBACK');
+        $fallbackExtractor->method('extractFromFunctionReturn')->willReturn('FALLBACK');
 
         $extractor = new PhpstanTypeExtractor($fallbackExtractor);
 
         $voidReflectionMethod = (new \ReflectionClass(PhpstanExtractableDummy::class))->getMethod('void');
         $neverReflectionMethod = (new \ReflectionClass(PhpstanExtractableDummy::class))->getMethod('never');
 
-        $this->assertSame('FALLBACK', $extractor->extractFromReturnType($voidReflectionMethod));
-        $this->assertSame('FALLBACK', $extractor->extractFromReturnType($neverReflectionMethod));
+        $this->assertSame('FALLBACK', $extractor->extractFromFunctionReturn($voidReflectionMethod));
+        $this->assertSame('FALLBACK', $extractor->extractFromFunctionReturn($neverReflectionMethod));
     }
 
-    public function testExtractClassTypeFromFunctionReturnType(): void
+    public function testExtractClassTypeFromFunctionFunctionReturn(): void
     {
         $fallbackExtractor = $this->createStub(TypeExtractorInterface::class);
-        $fallbackExtractor->method('extractFromReturnType')->willReturn('FALLBACK');
+        $fallbackExtractor->method('extractFromFunctionReturn')->willReturn('FALLBACK');
 
         $extractor = new PhpstanTypeExtractor($fallbackExtractor);
 
@@ -96,7 +96,7 @@ public function testExtractClassTypeFromFunctionReturnType(): void
             return $this;
         });
 
-        $this->assertSame(self::class, $extractor->extractFromReturnType($selfReflectionFunction));
+        $this->assertSame(self::class, $extractor->extractFromFunctionReturn($selfReflectionFunction));
     }
 
     /**
@@ -105,27 +105,27 @@ public function testExtractClassTypeFromFunctionReturnType(): void
     public function testExtractFromParameter(string $expectedType, string $method): void
     {
         $fallbackExtractor = $this->createStub(TypeExtractorInterface::class);
-        $fallbackExtractor->method('extractFromParameter')->willReturn('FALLBACK');
+        $fallbackExtractor->method('extractFromFunctionParameter')->willReturn('FALLBACK');
 
         $extractor = new PhpstanTypeExtractor($fallbackExtractor);
 
         $reflectionParameter = (new \ReflectionClass(PhpstanExtractableDummy::class))->getMethod($method)->getParameters()[0];
 
-        $this->assertSame($expectedType, $extractor->extractFromParameter($reflectionParameter));
+        $this->assertSame($expectedType, $extractor->extractFromFunctionParameter($reflectionParameter));
     }
 
     public function testExtractClassTypeFromParameter(): void
     {
         $fallbackExtractor = $this->createStub(TypeExtractorInterface::class);
-        $fallbackExtractor->method('extractFromParameter')->willReturn('FALLBACK');
+        $fallbackExtractor->method('extractFromFunctionParameter')->willReturn('FALLBACK');
 
         $extractor = new PhpstanTypeExtractor($fallbackExtractor);
 
         /** @param self $_ */
         $selfReflectionFunction = new \ReflectionFunction(function ($_) {
         });
 
-        $this->assertSame(self::class, $extractor->extractFromParameter($selfReflectionFunction->getParameters()[0]));
+        $this->assertSame(self::class, $extractor->extractFromFunctionParameter($selfReflectionFunction->getParameters()[0]));
     }
 
     /**
diff --git a/Tests/Type/ReflectionTypeExtractorTest.php b/Tests/Type/ReflectionTypeExtractorTest.php
@@ -50,11 +50,11 @@ public function testThrowIfCannotFindPropertyType(): void
     /**
      * @dataProvider typesDataProvider
      */
-    public function testExtractFromReturnType(string $expectedType, string $method): void
+    public function testExtractFromFunctionReturn(string $expectedType, string $method): void
     {
         $reflectionMethod = (new \ReflectionClass(ReflectionExtractableDummy::class))->getMethod($method);
 
-        $this->assertSame($expectedType, (new ReflectionTypeExtractor())->extractFromReturnType($reflectionMethod));
+        $this->assertSame($expectedType, (new ReflectionTypeExtractor())->extractFromFunctionReturn($reflectionMethod));
     }
 
     public function testExtractClassTypeFromFunctionReturnType(): void
@@ -63,13 +63,13 @@ public function testExtractClassTypeFromFunctionReturnType(): void
             return $this;
         });
 
-        $this->assertSame(self::class, (new ReflectionTypeExtractor())->extractFromReturnType($selfReflectionFunction));
+        $this->assertSame(self::class, (new ReflectionTypeExtractor())->extractFromFunctionReturn($selfReflectionFunction));
 
         $parentReflectionFunction = new \ReflectionFunction(function (): parent {
             return $this;
         });
 
-        $this->assertSame(parent::class, (new ReflectionTypeExtractor())->extractFromReturnType($parentReflectionFunction));
+        $this->assertSame(parent::class, (new ReflectionTypeExtractor())->extractFromFunctionReturn($parentReflectionFunction));
     }
 
     public function testCannotHandleIntersectionReturnType(): void
@@ -78,7 +78,7 @@ public function testCannotHandleIntersectionReturnType(): void
 
         $this->expectException(UnsupportedTypeException::class);
 
-        (new ReflectionTypeExtractor())->extractFromReturnType($reflectionMethod);
+        (new ReflectionTypeExtractor())->extractFromFunctionReturn($reflectionMethod);
     }
 
     public function testCannotHandleVoidReturnType(): void
@@ -87,7 +87,7 @@ public function testCannotHandleVoidReturnType(): void
 
         $this->expectException(UnsupportedTypeException::class);
 
-        (new ReflectionTypeExtractor())->extractFromReturnType($reflectionMethod);
+        (new ReflectionTypeExtractor())->extractFromFunctionReturn($reflectionMethod);
     }
 
     public function testCannotHandleNeverReturnType(): void
@@ -96,7 +96,7 @@ public function testCannotHandleNeverReturnType(): void
 
         $this->expectException(UnsupportedTypeException::class);
 
-        (new ReflectionTypeExtractor())->extractFromReturnType($reflectionMethod);
+        (new ReflectionTypeExtractor())->extractFromFunctionReturn($reflectionMethod);
     }
 
     public function testThrowIfCannotFindReturnType(): void
@@ -105,7 +105,7 @@ public function testThrowIfCannotFindReturnType(): void
 
         $reflectionMethod = (new \ReflectionClass(ReflectionExtractableDummy::class))->getMethod('undefined');
 
-        (new ReflectionTypeExtractor())->extractFromReturnType($reflectionMethod);
+        (new ReflectionTypeExtractor())->extractFromFunctionReturn($reflectionMethod);
     }
 
     /**
@@ -115,7 +115,7 @@ public function testExtractFromParameter(string $expectedType, string $method):
     {
         $reflectionParameter = (new \ReflectionClass(ReflectionExtractableDummy::class))->getMethod($method)->getParameters()[0];
 
-        $this->assertSame($expectedType, (new ReflectionTypeExtractor())->extractFromParameter($reflectionParameter));
+        $this->assertSame($expectedType, (new ReflectionTypeExtractor())->extractFromFunctionParameter($reflectionParameter));
     }
 
     public function testThrowIfCannotFindParameterType(): void
@@ -124,7 +124,7 @@ public function testThrowIfCannotFindParameterType(): void
 
         $reflectionParameter = (new \ReflectionClass(ReflectionExtractableDummy::class))->getMethod('undefined')->getParameters()[0];
 
-        (new ReflectionTypeExtractor())->extractFromParameter($reflectionParameter);
+        (new ReflectionTypeExtractor())->extractFromFunctionParameter($reflectionParameter);
     }
 
     /**
diff --git a/Type/PhpstanTypeExtractor.php b/Type/PhpstanTypeExtractor.php
@@ -50,10 +50,10 @@ public function extractFromProperty(\ReflectionProperty $property): string
         return $this->phpstanTypeHelper->getType($typeNode, $property->getDeclaringClass()->getName(), $this->getTemplateNodes($property->getDeclaringClass()));
     }
 
-    public function extractFromReturnType(\ReflectionFunctionAbstract $function): string
+    public function extractFromFunctionReturn(\ReflectionFunctionAbstract $function): string
     {
         if (null === $typeNode = $this->getTypeNode($function)) {
-            return $this->decoratedTypeExtractor->extractFromReturnType($function);
+            return $this->decoratedTypeExtractor->extractFromFunctionReturn($function);
         }
 
         $declaringClass = $function instanceof \ReflectionMethod ? $function->getDeclaringClass() : $function->getClosureScopeClass();
@@ -64,10 +64,10 @@ public function extractFromReturnType(\ReflectionFunctionAbstract $function): st
         return $this->phpstanTypeHelper->getType($typeNode, $declaringClass->getName(), $this->getTemplateNodes($declaringClass));
     }
 
-    public function extractFromParameter(\ReflectionParameter $parameter): string
+    public function extractFromFunctionParameter(\ReflectionParameter $parameter): string
     {
         if (null === $typeNode = $this->getTypeNode($parameter)) {
-            return $this->decoratedTypeExtractor->extractFromParameter($parameter);
+            return $this->decoratedTypeExtractor->extractFromFunctionParameter($parameter);
         }
 
         $function = $parameter->getDeclaringFunction();
diff --git a/Type/ReflectionTypeExtractor.php b/Type/ReflectionTypeExtractor.php
@@ -26,8 +26,7 @@ public function extractFromProperty(\ReflectionProperty $property): string
         return $this->extractFromReflection($type, $property->getDeclaringClass());
     }
 
-    // TODO FunctionReturn
-    public function extractFromReturnType(\ReflectionFunctionAbstract $function): string
+    public function extractFromFunctionReturn(\ReflectionFunctionAbstract $function): string
     {
         /** @var \ReflectionClass<object>|null $declaringClass */
         $declaringClass = $function instanceof \ReflectionMethod ? $function->getDeclaringClass() : $function->getClosureScopeClass();
@@ -39,8 +38,7 @@ public function extractFromReturnType(\ReflectionFunctionAbstract $function): st
         return $this->extractFromReflection($type, $declaringClass);
     }
 
-    // TODO FunctionParameter
-    public function extractFromParameter(\ReflectionParameter $parameter): string
+    public function extractFromFunctionParameter(\ReflectionParameter $parameter): string
     {
         $function = $parameter->getDeclaringFunction();
 
diff --git a/Type/TypeExtractorInterface.php b/Type/TypeExtractorInterface.php
@@ -16,9 +16,9 @@ interface TypeExtractorInterface
 {
     public function extractFromProperty(\ReflectionProperty $property): string;
 
-    public function extractFromReturnType(\ReflectionFunctionAbstract $function): string;
+    public function extractFromFunctionReturn(\ReflectionFunctionAbstract $function): string;
 
-    public function extractFromParameter(\ReflectionParameter $parameter): string;
+    public function extractFromFunctionParameter(\ReflectionParameter $parameter): string;
 
     /**
      * @param \ReflectionClass<object> $class
diff --git a/Type/TypeNameResolver.php b/Type/TypeNameResolver.php
@@ -17,7 +17,6 @@
  *
  * @internal
  */
-// TODO test
 final class TypeNameResolver
 {
     /**

Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,6 @@ public static function createForProperty(\ReflectionProperty $property): self`
`24`	`24`	`return new self(sprintf('%s::$%s', $property->getDeclaringClass()->getName(), $property->getName()), 'property');`
`25`	`25`	`}`
`26`	`26`
`27`		`- // TODO ReturnType -> FunctionReturn`
`28`		`-`
`29`	`27`	`public static function createForFunctionReturn(\ReflectionFunctionAbstract $function): self`
`30`	`28`	`{`
`31`	`29`	`/** @var \ReflectionClass<object>\|null $declaringClass */`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ private function name(\ReflectionProperty $property, string $propertyIdentifier,`
`67`	`67`	`private function type(\ReflectionProperty $property, ?\ReflectionFunction $propertyFormatter, array $context): string`
`68`	`68`	`{`
`69`	`69`	`return null !== $propertyFormatter`
`70`		`- ? $this->typeExtractor->extractFromReturnType($propertyFormatter)`
	`70`	`+ ? $this->typeExtractor->extractFromFunctionReturn($propertyFormatter)`
`71`	`71`	`: $this->typeExtractor->extractFromProperty($property);`
`72`	`72`	`}`
`73`	`73`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public function __invoke(\ReflectionClass $class, object $object, string $key, c`
`39`	`39`	`$propertyFormatterReflection = new \ReflectionFunction($propertyFormatter);`
`40`	`40`	`$this->validateFormatter($propertyFormatterReflection, $propertyIdentifier);`
`41`	`41`
`42`		`- $valueType = $this->typeExtractor->extractFromParameter($propertyFormatterReflection->getParameters()[0]);`
	`42`	`+ $valueType = $this->typeExtractor->extractFromFunctionParameter($propertyFormatterReflection->getParameters()[0]);`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`$valueType ??= $this->typeExtractor->extractFromProperty(new \ReflectionProperty($object, $propertyName));`
Original file line number	Diff line number	Diff line change
`@@ -180,8 +180,6 @@ private function instantiateObject(\ReflectionClass $reflection): object`
`180`	`180`	`continue;`
`181`	`181`	`}`
`182`	`182`
`183`		`- // TODO throw or collect depending on context (like in AbstractNormalizer)`
`184`		`-`
`185`	`183`	`return $reflection->newInstanceWithoutConstructor();`
`186`	`184`	`}`
`187`	`185`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public function testUpdateTypeAccessorAndContextFromFormatter(string $expectedTy`
`59`	`59`	`{`
`60`	`60`	`$typeExtractor = $this->createStub(TypeExtractorInterface::class);`
`61`	`61`	`$typeExtractor->method('extractFromProperty')->willReturn('int');`
`62`		`- $typeExtractor->method('extractFromReturnType')->willReturn('string');`
	`62`	`+ $typeExtractor->method('extractFromFunctionReturn')->willReturn('string');`
`63`	`63`
`64`	`64`	`$context = [`
`65`	`65`	`'symfony' => [`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public function testRetrieveActualPropertyName(): void`
`68`	`68`	`public function testFormatValue(): void`
`69`	`69`	`{`
`70`	`70`	`$typeExtractor = $this->createStub(TypeExtractorInterface::class);`
`71`		`- $typeExtractor->method('extractFromParameter')->willReturn('string');`
	`71`	`+ $typeExtractor->method('extractFromFunctionParameter')->willReturn('string');`
`72`	`72`
`73`	`73`	`$object = new class() {`
`74`	`74`	`public string $foo;`