WIP: TASK combine EnumMemberType into EnumInstanceType

this modeling is imo correct, as this will allow this in the future

```
Enum.A.value
```

`Enum.A` is an EnumInstanceType (which knows that its name is "A") while Enum is just an EnumStaticType

if an enum is referenced like

`enum: Enum`

an unspecific instance (without known MemberName) will be used

Author: mhsdesign

src/TypeSystem/Resolver/Access/AccessTypeResolver.php

@@ -26,7 +26,7 @@
 use PackageFactory\ComponentEngine\Parser\Ast\AccessNode;
 use PackageFactory\ComponentEngine\TypeSystem\Resolver\Expression\ExpressionTypeResolver;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
-use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumMemberType;
+use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumInstanceType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumStaticType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\StructType\StructType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
@@ -45,13 +45,13 @@ public function resolveTypeOf(AccessNode $accessNode): TypeInterface
         $rootType = $expressionResolver->resolveTypeOf($accessNode->root);
 
         return match ($rootType::class) {
-            EnumStaticType::class => $this->createEnumMemberType($accessNode, $rootType),
+            EnumStaticType::class => $this->createEnumInstanceMemberType($accessNode, $rootType),
             StructType::class => throw new \Exception('@TODO: StructType Access is not implemented'),
             default => throw new \Exception('@TODO Error: Cannot access on type ' . $rootType::class)
         };
     }
 
-    private function createEnumMemberType(AccessNode $accessNode, EnumStaticType $enumType): EnumMemberType
+    private function createEnumInstanceMemberType(AccessNode $accessNode, EnumStaticType $enumType): EnumInstanceType
     {
         if (!(
             count($accessNode->chain->items) === 1

src/TypeSystem/Resolver/Match/MatchTypeResolver.php

@@ -27,7 +27,6 @@
 use PackageFactory\ComponentEngine\TypeSystem\Resolver\Expression\ExpressionTypeResolver;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 use PackageFactory\ComponentEngine\TypeSystem\Type\BooleanType\BooleanType;
-use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumMemberType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumInstanceType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
@@ -106,12 +105,12 @@ private function resolveTypeOfEnumMatch(MatchNode $matchNode, EnumInstanceType $
             } else {
                 foreach ($matchArmNode->left->items as $expressionNode) {
                     $enumMemberType = $expressionTypeResolver->resolveTypeOf($expressionNode);
-                    if (!$enumMemberType instanceof EnumMemberType) {
+                    if (!$enumMemberType instanceof EnumInstanceType) {
                         throw new \Error('@TODO Error: Cannot match enum with type of ' . $enumMemberType::class);
                     }
 
-                    if (!$enumMemberType->enumType->is($subjectEnumType)) {
-                        throw new \Error('@TODO Error: incompatible enum match: got ' . $enumMemberType->enumType->enumName . ' expected ' . $subjectEnumType->enumName);
+                    if (!$enumMemberType->enumStaticType->is($subjectEnumType->enumStaticType)) {
+                        throw new \Error('@TODO Error: incompatible enum match: got ' . $enumMemberType->enumStaticType->enumName . ' expected ' . $subjectEnumType->enumStaticType->enumName);
                     }
 
                     if (isset($referencedEnumMembers[$enumMemberType->memberName])) {
@@ -128,7 +127,7 @@ private function resolveTypeOfEnumMatch(MatchNode $matchNode, EnumInstanceType $
         }
 
         if (!$defaultArmPresent) {
-            foreach ($subjectEnumType->getMemberNames() as $member) {
+            foreach ($subjectEnumType->enumStaticType->getMemberNames() as $member) {
                 if (!isset($referencedEnumMembers[$member])) {
                     throw new \Error('@TODO Error: member ' . $member . ' not checked');
                 }

src/TypeSystem/Type/EnumType/EnumInstanceType.php

@@ -26,5 +26,33 @@
 
 final class EnumInstanceType implements TypeInterface
 {
-    use EnumTrait;
+    private function __construct(
+        public readonly EnumStaticType $enumStaticType,
+        public readonly ?string $memberName
+    ) {
+        if ($memberName !== null && !$enumStaticType->hasMember($memberName)) {
+            throw new \Exception('@TODO cannot access member ' . $memberName . ' of enum ' . $this->enumStaticType->enumName);
+        }
+    }
+
+    public static function fromStaticEnumCreateUnspecificInstance(EnumStaticType $enumStaticType): self
+    {
+        return new self(
+            enumStaticType: $enumStaticType,
+            memberName: null
+        );
+    }
+    
+    public static function fromStaticEnumAndMemberName(EnumStaticType $enumStaticType, string $enumMemberName): self
+    {
+        return new self(
+            enumStaticType: $enumStaticType,
+            memberName: $enumMemberName
+        );
+    }
+
+    public function is(TypeInterface $other): bool
+    {
+        return false;
+    }
 }

src/TypeSystem/Type/EnumType/EnumMemberType.php

@@ -22,14 +22,65 @@
 
 namespace PackageFactory\ComponentEngine\TypeSystem\Type\EnumType;
 
+use PackageFactory\ComponentEngine\Module\ModuleId;
+use PackageFactory\ComponentEngine\Parser\Ast\EnumDeclarationNode;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
 final class EnumStaticType implements TypeInterface
 {
-    use EnumTrait;
-    
+    public function __construct(
+        public readonly string $enumName,
+        private readonly ModuleId $moduleId,
+        private readonly array $memberNameHashMap,
+    ) {
+    }
+
+    public static function fromModuleIdAndDeclaration(ModuleId $moduleId, EnumDeclarationNode $enumDeclarationNode): self
+    {
+        $memberNameHashMap = [];
+        foreach ($enumDeclarationNode->memberDeclarations->items as $memberDeclarationNode) {
+            $memberNameHashMap[$memberDeclarationNode->name] = true;
+        }
+
+        return new self(
+            enumName: $enumDeclarationNode->enumName,
+            moduleId: $moduleId,
+            memberNameHashMap: $memberNameHashMap
+        );
+    }
+
+    public function getMemberNames(): array
+    {
+        return array_keys($this->memberNameHashMap);
+    }
+
+    public function hasMember(string $memberName): bool
+    {
+        return array_key_exists($memberName, $this->memberNameHashMap);
+    }
+
+    public function getMemberType(string $memberName): EnumInstanceType
+    {
+        return EnumInstanceType::fromStaticEnumAndMemberName(
+            $this,
+            $memberName
+        );
+    }
+
+    public function is(TypeInterface $other): bool
+    {
+        if ($other === $this) {
+            return true;
+        }
+        if ($other instanceof EnumStaticType) {
+            return $this->moduleId === $other->moduleId
+                && $this->enumName === $other->enumName;
+        }
+        return false;
+    }
+
     public function toEnumInstanceType(): EnumInstanceType
     {
-        return new EnumInstanceType($this->moduleId, $this->enumName, $this->memberNameHashMap);
+        return EnumInstanceType::fromStaticEnumCreateUnspecificInstance($this);
     }
 }

src/TypeSystem/Type/EnumType/EnumStaticType.php

@@ -29,7 +29,7 @@
 use PackageFactory\ComponentEngine\Test\Unit\TypeSystem\Scope\Fixtures\DummyScope;
 use PackageFactory\ComponentEngine\TypeSystem\Resolver\Access\AccessTypeResolver;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
-use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumMemberType;
+use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumInstanceType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumStaticType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\StringType\StringType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
@@ -68,7 +68,7 @@ private function resolveAccessType(string $accessAsString, ScopeInterface $scope
     /**
      * @test
      */
-    public function access(): void
+    public function enumMemberAccessOnStaticEnum(): void
     {
         $someEnum = EnumStaticType::fromModuleIdAndDeclaration(
             ModuleId::fromString("module-a"),
@@ -86,9 +86,9 @@ public function access(): void
             $scope
         );
 
-        $this->assertInstanceOf(EnumMemberType::class, $accessType);
+        $this->assertInstanceOf(EnumInstanceType::class, $accessType);
 
-        $this->assertTrue($accessType->enumType->is($someEnum));
+        $this->assertTrue($accessType->enumStaticType->is($someEnum));
 
         $this->assertEquals("A", $accessType->memberName);
     }