fix: properly handle class sharing class name and namespace group name

src/Type/Parser/Factory/Specifications/AliasSpecification.php

@@ -12,6 +12,10 @@
 use ReflectionFunction;
 use Reflector;
 
+use function array_shift;
+use function explode;
+use function strtolower;
+
 /** @internal */
 final class AliasSpecification implements TypeParserSpecification
 {
@@ -52,10 +56,10 @@ private function resolveAlias(string $symbol): string
         $alias = $symbol;
 
         $namespaceParts = explode('\\', $symbol);
-        $lastPart = array_shift($namespaceParts);
+        $firstPart = array_shift($namespaceParts);
 
-        if ($lastPart) {
-            $alias = strtolower($lastPart);
+        if ($firstPart) {
+            $alias = strtolower($firstPart);
         }
 
         $aliases = PhpParser::parseUseStatements($this->reflection);
@@ -64,17 +68,17 @@ private function resolveAlias(string $symbol): string
             return $symbol;
         }
 
-        if ($aliases[$alias] === $symbol) {
-            return $symbol;
-        }
+        $fqcn = $aliases[$alias]['fqcn'];
 
-        $full = $aliases[$alias];
+        if ($namespaceParts === []) {
+            return $fqcn;
+        }
 
-        if (! empty($namespaceParts)) {
-            $full .= '\\' . implode('\\', $namespaceParts);
+        if (! $aliases[$alias]['isExplicitAlias']) {
+            return $symbol;
         }
 
-        return $full;
+        return $fqcn . '\\' . implode('\\', $namespaceParts);
     }
 
     private function resolveNamespaced(string $symbol): string

src/Utility/Reflection/PhpParser.php

@@ -17,12 +17,12 @@
  */
 final class PhpParser
 {
-    /** @var array<string, array<string, string>> */
+    /** @var array<string, array<non-empty-string, array{fqcn: non-empty-string, isExplicitAlias: bool}>> */
     private static array $statements = [];
 
     /**
      * @param ReflectionClass<object>|ReflectionFunction|ReflectionMethod $reflection
-     * @return array<string, string>
+     * @return array<non-empty-string, array{fqcn: non-empty-string, isExplicitAlias: bool}>
      */
     public static function parseUseStatements(\ReflectionClass|\ReflectionFunction|\ReflectionMethod $reflection): array
     {
@@ -34,7 +34,7 @@ public static function parseUseStatements(\ReflectionClass|\ReflectionFunction|\
 
     /**
      * @param ReflectionClass<object>|ReflectionFunction|ReflectionMethod $reflection
-     * @return array<string, string>
+     * @return array<non-empty-string, array{fqcn: non-empty-string, isExplicitAlias: bool}>
      */
     private static function fetchUseStatements(\ReflectionClass|\ReflectionFunction|\ReflectionMethod $reflection): array
     {

src/Utility/Reflection/TokenParser.php

@@ -29,7 +29,7 @@ public function __construct(string $content)
     }
 
     /**
-     * @return array<string, string>
+     * @return array<non-empty-string, array{fqcn: non-empty-string, isExplicitAlias: bool}>
      */
     public function parseUseStatements(string $namespaceName): array
     {
@@ -58,7 +58,7 @@ public function parseUseStatements(string $namespaceName): array
     }
 
     /**
-     * @return array<string, string>
+     * @return array<non-empty-string, array{fqcn: non-empty-string, isExplicitAlias: bool}>
      */
     private function parseUseStatement(): array
     {
@@ -86,12 +86,18 @@ private function parseUseStatement(): array
                 $explicitAlias = true;
                 $alias = '';
             } elseif ($name === ',') {
-                $statements[strtolower($alias)] = $groupRoot . $class;
+                $statements[strtolower($alias)] = [
+                    'fqcn' => $groupRoot . $class,
+                    'isExplicitAlias' => $explicitAlias,
+                ];
                 $class = $alias = '';
                 $explicitAlias = false;
             } elseif ($name === ';') {
                 if ($alias !== '') {
-                    $statements[strtolower($alias)] = $groupRoot . $class;
+                    $statements[strtolower($alias)] = [
+                        'fqcn' => $groupRoot . $class,
+                        'isExplicitAlias' => $explicitAlias,
+                    ];
                 }
                 break;
             } elseif ($name === '{') {
@@ -100,6 +106,7 @@ private function parseUseStatement(): array
             }
         }
 
+        /** @var array<non-empty-string, array{fqcn: non-empty-string, isExplicitAlias: bool}> */
         return $statements;
     }
 

tests/Integration/Mapping/Namespace/SameClassNameAsNamespaceGroupMappingTest.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CuyZ\Valinor\Tests\Integration\Mapping\Namespace;
+
+use CuyZ\Valinor\Mapper\MappingError;
+use CuyZ\Valinor\Tests\Integration\IntegrationTestCase;
+use SomeNamespace\SomeClass;
+use SomeNamespace\SomeNamespace;
+
+final class SameClassNameAsNamespaceGroupMappingTest extends IntegrationTestCase
+{
+    // @see https://github.com/CuyZ/Valinor/issues/554
+    public function test_class_name_has_same_name_as_namespace_group_dot_not_block_type_resolution(): void
+    {
+        require_once 'class-name-with-same-name-as-namespace-group.php';
+
+        try {
+            $result = $this->mapperBuilder()->mapper()->map(ClassContainingNamespacedClasses::class, [
+                'objectA' => ['stringValue' => 'foo'],
+                'objectB' => ['integerValue' => 42],
+            ]);
+        } catch (MappingError $error) {
+            $this->mappingFail($error);
+        }
+
+        self::assertSame('foo', $result->objectA->stringValue);
+        self::assertSame(42, $result->objectB->integerValue);
+    }
+}
+
+final class ClassContainingNamespacedClasses
+{
+    public SomeNamespace $objectA;
+    public SomeClass $objectB;
+}

tests/Integration/Mapping/Namespace/class-name-with-same-name-as-namespace-group.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace SomeNamespace;
+
+final class SomeNamespace
+{
+    public string $stringValue;
+}
+
+final class SomeClass
+{
+    public int $integerValue;
+}