Add source info to class and property hooks

Author: SerafimArts

src/Mapping/Metadata/ClassInfo.php

@@ -10,7 +10,7 @@
 /**
  * @template T of object
  */
-final class ClassInfo
+final class ClassInfo extends MetadataInfo
 {
     /**
      * @var array<non-empty-string, PropertyInfo>
@@ -33,7 +33,10 @@ public function __construct(
          * @var class-string<T>
          */
         public readonly string $name,
-    ) {}
+        ?SourceInfo $source = null,
+    ) {
+        parent::__construct($source);
+    }
 
     /**
      * @param non-empty-string $name

src/Mapping/Provider/MetadataReaderProvider.php

@@ -54,6 +54,8 @@ public function getClassMetadata(
     ): ClassMetadata {
         $info = $this->reader->read($class);
 
+        dd($info);
+
         return $this->toClassMetadata($info, $types, $parser);
     }
 

src/Mapping/Reader/MetadataReader.php

@@ -5,6 +5,7 @@
 namespace TypeLang\Mapper\Mapping\Reader;
 
 use TypeLang\Mapper\Mapping\Metadata\ClassInfo;
+use TypeLang\Mapper\Mapping\Metadata\SourceInfo;
 use TypeLang\Mapper\Mapping\Reader\MetadataReader\ClassMetadataLoaderInterface;
 use TypeLang\Mapper\Mapping\Reader\MetadataReader\PropertyMetadataLoaderInterface;
 
@@ -20,6 +21,15 @@ public function read(\ReflectionClass $class): ClassInfo
     {
         $classInfo = parent::read($class);
 
+        if ($classInfo->source === null) {
+            $file = $class->getFileName();
+            $line = $class->getStartLine();
+
+            if (\is_string($file) && $line > 0) {
+                $classInfo->source = new SourceInfo($file, $line);
+            }
+        }
+
         foreach ($this->classLoaders as $classLoader) {
             $classLoader->load($classInfo, $class);
         }

src/Mapping/Reader/ReflectionReader/TypePropertyReflectionLoader.php

@@ -17,74 +17,105 @@ public function load(PropertyInfo $info, \ReflectionProperty $property): void
         $this->loadWriteType($property, $info);
     }
 
-    private function findSourceMap(\ReflectionProperty $property): ?SourceInfo
-    {
-        $class = $property->getDeclaringClass();
-
-        if ($class->isInternal()) {
-            return null;
-        }
-
-        $file = $class->getFileName();
-        $line = $class->getStartLine();
-
-        if ($file === false || $line < 1) {
-            return null;
-        }
-
-        return new SourceInfo($file, $line);
-    }
-
     private function loadReadType(\ReflectionProperty $property, PropertyInfo $info): void
     {
-        $definition = $this->getReadTypeDefinition($property);
+        $definition = $this->getReadTypeInfo($property);
 
-        $info->read = $info->write = new TypeInfo($definition, $this->findSourceMap($property));
+        $info->read = $info->write = $definition;
     }
 
     private function loadWriteType(\ReflectionProperty $property, PropertyInfo $info): void
     {
-        $definition = $this->findWriteTypeDefinition($property);
+        $definition = $this->findWriteTypeInfo($property);
 
         if ($definition === null) {
             return;
         }
 
-        $info->write = new TypeInfo($definition, $this->findSourceMap($property));
+        $info->write = $definition;
     }
 
     /**
-     * @return non-empty-string
      * @throws \InvalidArgumentException
      */
-    private function findWriteTypeDefinition(\ReflectionProperty $property): ?string
+    private function findWriteTypeInfo(\ReflectionProperty $property): ?TypeInfo
     {
         if (\PHP_VERSION_ID < 80400) {
             return null;
         }
 
+        // Force skip in case of setter is not defined
+        if ($property->getHook(\PropertyHookType::Set) === null) {
+            return null;
+        }
+
+        $definition = $this->createMixedTypeDefinition();
         $type = $property->getSettableType();
 
-        if ($type === null) {
-            return $this->createMixedTypeDefinition();
+        if ($type !== null) {
+            $definition = $this->createTypeDefinition($type);
+        }
+
+        return new TypeInfo(
+            definition: $definition,
+            source: $this->getWriteHookSourceInfo($property),
+        );
+    }
+
+    private function getWriteHookSourceInfo(\ReflectionProperty $property): ?SourceInfo
+    {
+        if (\PHP_VERSION_ID < 80400) {
+            return null;
         }
 
-        return $this->createTypeDefinition($type);
+        return $this->getHookSourceInfo(
+            hook: $property->getHook(\PropertyHookType::Set),
+        );
     }
 
     /**
-     * @return non-empty-string
      * @throws \InvalidArgumentException
      */
-    private function getReadTypeDefinition(\ReflectionProperty $property): string
+    private function getReadTypeInfo(\ReflectionProperty $property): TypeInfo
     {
+        $definition = $this->createMixedTypeDefinition();
         $type = $property->getType();
 
-        if ($type === null) {
-            return $this->createMixedTypeDefinition();
+        if ($type !== null) {
+            $definition = $this->createTypeDefinition($type);
         }
 
-        return $this->createTypeDefinition($type);
+        return new TypeInfo(
+            definition: $definition,
+            source: $this->getReadHookSourceInfo($property),
+        );
+    }
+
+    private function getReadHookSourceInfo(\ReflectionProperty $property): ?SourceInfo
+    {
+        if (\PHP_VERSION_ID < 80400) {
+            return null;
+        }
+
+        return $this->getHookSourceInfo(
+            hook: $property->getHook(\PropertyHookType::Get),
+        );
+    }
+
+    private function getHookSourceInfo(?\ReflectionMethod $hook): ?SourceInfo
+    {
+        if ($hook === null) {
+            return null;
+        }
+
+        $file = $hook->getFileName();
+        $line = $hook->getStartLine();
+
+        if (\is_string($file) && $file !== '' && $line > 0) {
+            return new SourceInfo($file, $line);
+        }
+
+        return null;
     }
 
     /**
@@ -131,9 +162,15 @@ private function createNamedTypeDefinition(\ReflectionNamedType $type): string
      */
     private function createNonNullNamedTypeDefinition(\ReflectionNamedType $type): string
     {
+        $literal = $type->getName();
+
+        // PHP 8.4 Setter's type bug
+        if (\str_starts_with($literal, '?')) {
+            $literal = \substr($literal, 1);
+        }
+
         /** @phpstan-ignore-next-line : Type's name cannot be empty */
         $name = new Name($type->getName());
-        $literal = $name->toString();
 
         if ($type->isBuiltin() || $name->isSpecial() || $name->isBuiltin()) {
             return $literal;