Fix references resolver behaviour

Author: SerafimArts

src/Mapping/Reference/Reader/NativeReferencesReader.php

@@ -81,7 +81,7 @@ private function readNamespace(\Iterator $tokens): string
         while ($tokens->valid()) {
             $current = $tokens->current();
 
-            if ($current->id === \T_NAME_QUALIFIED) {
+            if ($current->id === \T_NAME_QUALIFIED || $current->id === \T_STRING) {
                 $result = $current->text;
             } elseif ($current->text === ';') {
                 $tokens->next();

src/Mapping/Reference/ReferencesResolver.php

@@ -4,6 +4,7 @@
 
 namespace TypeLang\Mapper\Mapping\Reference;
 
+use phpDocumentor\Reflection\Types\True_;
 use TypeLang\Mapper\Mapping\Reference\Reader\ReferencesReaderInterface;
 use TypeLang\Parser\Node\Name;
 use TypeLang\Parser\Node\Stmt\TypeStatement;
@@ -79,19 +80,18 @@ private function formatUseStatements(array $uses): array
         $result = [];
 
         foreach ($uses as $alias => $fqn) {
+            // In case of "use Some as Alias;" stmt found
             if (\is_string($alias)) {
                 $result[$alias] = $fqn;
                 continue;
             }
 
-            $nameOffset = \strrpos($fqn, '\\');
+            // In case of "use Some;" or "use Some\Any;" stmts found
+            $className = ($nameOffset = \strrpos($fqn, '\\')) !== false
+                ? \substr($fqn, $nameOffset + 1)
+                : $fqn;
 
-            if ($nameOffset === false) {
-                $result[$fqn] = $fqn;
-                continue;
-            }
-
-            dd($nameOffset);
+            $result[$className] = $fqn;
         }
 
         return $result;
@@ -115,7 +115,22 @@ private function fromCurrentNamespace(Name $name, \ReflectionClass $class): Name
             return $name;
         }
 
-        return (new Name($namespace))
+        $result = (new Name($namespace))
             ->withAdded($name);
+
+        if ($this->isClassExists($result)) {
+            return $result;
+        }
+
+        return $name;
+    }
+
+    private function isClassExists(Name $name): bool
+    {
+        $fqn = $name->toString();
+
+        return \class_exists($fqn)
+            || \interface_exists($fqn, false)
+            || \trait_exists($fqn, false);
     }
 }

tests/Mapping/Reference/ReferencesResolverTest.php

@@ -26,14 +26,14 @@ private function getResolver(array $useStatements = []): ReferencesResolver
     #[TestDox('if no "use" stmt, then the namespace must be same as the class')]
     public function testResolveWithSimpleNameInSameNamespace(): void
     {
-        $needle = new NamedTypeNode('TestClass');
+        $needle = new NamedTypeNode('ClassWithGroupUsesStub');
         $haystack = new \ReflectionClass(SimpleClassStub::class);
 
         $result = $this->getResolver()
             ->resolve($needle, $haystack);
 
         self::assertInstanceOf(NamedTypeNode::class, $result);
-        self::assertSame('TypeLang\Mapper\Tests\Mapping\Reference\Stub\TestClass', $result->name->toString());
+        self::assertSame('TypeLang\Mapper\Tests\Mapping\Reference\Stub\ClassWithGroupUsesStub', $result->name->toString());
     }
 
     public function testResolveWithUseStatement(): void
@@ -67,14 +67,14 @@ public function testResolveWithAliasedUseStatement(): void
 
     public function testResolveWithNamespaceKeyword(): void
     {
-        $needle = new NamedTypeNode('namespace\\TestClass');
+        $needle = new NamedTypeNode('namespace\\Attribute');
         $haystack = new \ReflectionClass(SimpleClassStub::class);
 
         $result = $this->getResolver()
             ->resolve($needle, $haystack);
 
         self::assertInstanceOf(NamedTypeNode::class, $result);
-        self::assertSame('TypeLang\\Mapper\\Tests\\Mapping\\Reference\\Stub\\TestClass', $result->name->toString());
+        self::assertSame('Attribute', $result->name->toString());
     }
 
     public function testResolveWithNamespaceKeywordInGlobalNamespace(): void
@@ -110,7 +110,7 @@ public function testResolveWithComplexNamespaceKeyword(): void
             ->resolve($needle, $haystack);
 
         self::assertInstanceOf(NamedTypeNode::class, $result);
-        self::assertSame('TypeLang\\Mapper\\Tests\\Mapping\\Reference\\Stub\\Sub\\Namespace\\TestClass', $result->name->toString());
+        self::assertSame('Sub\\Namespace\\TestClass', $result->name->toString());
     }
 
     public function testResolveWithMixedUseStatements(): void