!!!TASK: Refactor all remaining Singletons with Singleton Trait

Author: grebaldi

src/Target/Php/Transpiler/ComponentDeclaration/ComponentDeclarationTranspiler.php

@@ -124,7 +124,7 @@ public function writeReturnExpression(ComponentDeclarationNode $componentDeclara
         );
 
         $returnExpression = $componentDeclarationNode->return;
-        $returnTypeIsString = StringType::get()->is(
+        $returnTypeIsString = StringType::singleton()->is(
             $expressionTypeResolver->resolveTypeOf($returnExpression)
         );
         $transpiledReturnExpression = $expressionTranspiler->transpile($returnExpression);

src/TypeSystem/Resolver/BinaryOperation/BinaryOperationTypeResolver.php

@@ -48,7 +48,7 @@ public function resolveTypeOf(BinaryOperationNode $binaryOperationNode): TypeInt
             BinaryOperator::GREATER_THAN,
             BinaryOperator::GREATER_THAN_OR_EQUAL,
             BinaryOperator::LESS_THAN,
-            BinaryOperator::LESS_THAN_OR_EQUAL => BooleanType::get()
+            BinaryOperator::LESS_THAN_OR_EQUAL => BooleanType::singleton()
         };
     }
 

src/TypeSystem/Resolver/BooleanLiteral/BooleanLiteralTypeResolver.php

@@ -30,6 +30,6 @@ final class BooleanLiteralTypeResolver
 {
     public function resolveTypeOf(BooleanLiteralNode $booleanLiteralNode): TypeInterface
     {
-        return BooleanType::get();
+        return BooleanType::singleton();
     }
 }

src/TypeSystem/Resolver/IntegerLiteral/IntegerLiteralTypeResolver.php

@@ -30,6 +30,6 @@ final class IntegerLiteralTypeResolver
 {
     public function resolveTypeOf(IntegerLiteralNode $IntegerLiteralNode): TypeInterface
     {
-        return IntegerType::get();
+        return IntegerType::singleton();
     }
 }

src/TypeSystem/Resolver/Match/MatchTypeResolver.php

@@ -138,7 +138,7 @@ public function resolveTypeOf(MatchNode $matchNode): TypeInterface
         );
 
         return match (true) {
-            BooleanType::get()->is($typeOfSubject) => $this->resolveTypeOfBooleanMatch($matchNode),
+            BooleanType::singleton()->is($typeOfSubject) => $this->resolveTypeOfBooleanMatch($matchNode),
             $typeOfSubject instanceof EnumInstanceType => $this->resolveTypeOfEnumMatch($matchNode, $typeOfSubject),
             default => throw new \Exception('@TODO: Not handled ' . $typeOfSubject::class)
         };

src/TypeSystem/Resolver/NullLiteral/NullLiteralTypeResolver.php

@@ -30,6 +30,6 @@ final class NullLiteralTypeResolver
 {
     public function resolveTypeOf(NullLiteralNode $nullLiteralNode): TypeInterface
     {
-        return NullType::get();
+        return NullType::singleton();
     }
 }

src/TypeSystem/Resolver/StringLiteral/StringLiteralTypeResolver.php

@@ -30,6 +30,6 @@ final class StringLiteralTypeResolver
 {
     public function resolveTypeOf(StringLiteralNode $stringLiteralNode): TypeInterface
     {
-        return StringType::get();
+        return StringType::singleton();
     }
 }

src/TypeSystem/Resolver/Tag/TagTypeResolver.php

@@ -30,6 +30,6 @@ final class TagTypeResolver
 {
     public function resolveTypeOf(TagNode $tagNode): TypeInterface
     {
-        return StringType::get();
+        return StringType::singleton();
     }
 }

src/TypeSystem/Resolver/TemplateLiteral/TemplateLiteralTypeResolver.php

@@ -30,6 +30,6 @@ final class TemplateLiteralTypeResolver
 {
     public function resolveTypeOf(TemplateLiteralNode $templateLiteralNode): TypeInterface
     {
-        return StringType::get();
+        return StringType::singleton();
     }
 }

src/TypeSystem/Scope/GlobalScope/GlobalScope.php

@@ -24,6 +24,7 @@
 
 use PackageFactory\ComponentEngine\Domain\TypeName\TypeName;
 use PackageFactory\ComponentEngine\Domain\VariableName\VariableName;
+use PackageFactory\ComponentEngine\Framework\PHP\Singleton\Singleton;
 use PackageFactory\ComponentEngine\TypeSystem\AtomicTypeInterface;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 use PackageFactory\ComponentEngine\TypeSystem\Type\BooleanType\BooleanType;
@@ -34,24 +35,15 @@
 
 final class GlobalScope implements ScopeInterface
 {
-    private static null|self $instance = null;
-
-    private function __construct()
-    {
-    }
-
-    public static function get(): self
-    {
-        return self::$instance ??= new self();
-    }
+    use Singleton;
 
     public function getType(TypeName $typeName): AtomicTypeInterface
     {
         return match ($typeName) {
-            StringType::get()->getName() => StringType::get(),
-            IntegerType::get()->getName() => IntegerType::get(),
-            BooleanType::get()->getName() => BooleanType::get(),
-            SlotType::get()->getName() => SlotType::get(),
+            StringType::singleton()->getName() => StringType::singleton(),
+            IntegerType::singleton()->getName() => IntegerType::singleton(),
+            BooleanType::singleton()->getName() => BooleanType::singleton(),
+            SlotType::singleton()->getName() => SlotType::singleton(),
             default => throw new \Exception('@TODO: Unknown Type ' . $typeName->value)
         };
     }