WIP: Task: cache ModuleFileLoader::resolveTypeOfImport

previously, every type lookup will result in re-parsing

Author: mhsdesign

src/Module/Loader/ModuleFile/ModuleFileLoader.php

@@ -39,31 +39,39 @@
 
 final class ModuleFileLoader implements LoaderInterface
 {
+    /** @var array<string, array<string, TypeInterface>> */
+    private array $cache = [];
+    
     public function resolveTypeOfImport(ImportNode $importNode): TypeInterface
     {
         $pathToImportFrom = $importNode->source->path->resolveRelationTo(
             Path::fromString($importNode->path)
         );
-        $source = Source::fromFile($pathToImportFrom->value);
-        $tokenizer = Tokenizer::fromSource($source);
-        $module = ModuleNode::fromTokens($tokenizer->getIterator());
-        $export = $module->exports->get($importNode->name->value);
 
-        if ($export === null) {
-            throw new \Exception(
-                '@TODO: Module "' . $importNode->path . '" has no exported member "' . $importNode->name->value . '".'
-            );
+        if (!isset($this->cache[$pathToImportFrom->value])) {
+            $source = Source::fromFile($pathToImportFrom->value);
+            $tokenizer = Tokenizer::fromSource($source);
+            $module = ModuleNode::fromTokens($tokenizer->getIterator());
+            $moduleId = ModuleId::fromSource($source);
+
+            foreach ($module->exports->items as $export) {
+                $this->cache[$pathToImportFrom->value][$importNode->name->value] = match ($export->declaration::class) {
+                    ComponentDeclarationNode::class => ComponentType::fromComponentDeclarationNode($export->declaration),
+                    EnumDeclarationNode::class => EnumStaticType::fromModuleIdAndDeclaration(
+                        $moduleId,
+                        $export->declaration,
+                    ),
+                    StructDeclarationNode::class => StructType::fromStructDeclarationNode($export->declaration)
+                };
+            }
         }
 
-        $moduleId = ModuleId::fromSource($source);
+        if ($type = $this->cache[$pathToImportFrom->value][$importNode->name->value] ?? null) {
+            return $type;
+        }
 
-        return match ($export->declaration::class) {
-            ComponentDeclarationNode::class => ComponentType::fromComponentDeclarationNode($export->declaration),
-            EnumDeclarationNode::class => EnumStaticType::fromModuleIdAndDeclaration(
-                $moduleId,
-                $export->declaration,
-            ),
-            StructDeclarationNode::class => StructType::fromStructDeclarationNode($export->declaration)
-        };
+        throw new \Exception(
+            '@TODO: Module "' . $importNode->path . '" has no exported member "' . $importNode->name->value . '".'
+        );
     }
 }

src/TypeSystem/Type/EnumType/EnumStaticType.php

@@ -73,6 +73,9 @@ public function is(TypeInterface $other): bool
             return true;
         }
         if ($other instanceof EnumStaticType) {
+            // @TODO this check is not needed actually since `EnumStaticType::fromModuleIdAndDeclaration`
+            // is cached inside \PackageFactory\ComponentEngine\Module\Loader\ModuleFile\ModuleFileLoader::resolveTypeOfImport
+            // so it "should" always be the same instance ...
             return $this->moduleId === $other->moduleId
                 && $this->enumName === $other->enumName;
         }

test/Unit/TypeSystem/Type/EnumType/EnumStaticTypeTest.php

@@ -152,6 +152,8 @@ public function canBeComparedToOther(): void
             $enumDeclarationNode
         );
 
+        $this->assertTrue($enumStaticType->is($enumStaticType));
+
         $enumStaticType2 = EnumStaticType::fromModuleIdAndDeclaration(
             ModuleId::fromString("module-a"),
             $enumDeclarationNode