WIP: Ternary Expression TypeNarrower for Nullables

src/Target/Php/Transpiler/TypeReference/TypeReferenceTranspiler.php

@@ -31,6 +31,8 @@
 use PackageFactory\ComponentEngine\TypeSystem\Type\SlotType\SlotType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\StringType\StringType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\StructType\StructType;
+use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
+use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
 final class TypeReferenceTranspiler
 {
@@ -43,22 +45,46 @@ public function __construct(
     public function transpile(TypeReferenceNode $typeReferenceNode): string
     {
         $type = $this->scope->resolveTypeReference($typeReferenceNode);
-        $phpTypeReference = match ($type::class) {
+
+        return match ($type::class) {
+            UnionType::class => $this->transpileUnionType($type, $typeReferenceNode),
+            default => $this->transpileNonUnionType($type, $typeReferenceNode)
+        };
+    }
+
+    private function transpileUnionType(UnionType $unionType, TypeReferenceNode $typeReferenceNode): string
+    {
+        if ($unionType->isNullable()) {
+            $nonNullable = $unionType->withoutNullable();
+            if ($nonNullable instanceof UnionType) {
+                throw new \Exception('@TODO Transpilation of nullable union types with more non null members is not implemented');
+            }
+            return $this->transpileNullableType($nonNullable, $typeReferenceNode);
+        }
+
+        throw new \Exception('@TODO Transpilation of complex union types is not implemented');
+    }
+
+    private function transpileNonUnionType(TypeInterface $type, TypeReferenceNode $typeReferenceNode): string
+    {
+        return match ($type::class) {
             NumberType::class => 'int|float',
             StringType::class => 'string',
             BooleanType::class => 'bool',
             SlotType::class => $this->strategy->getPhpTypeReferenceForSlotType($type, $typeReferenceNode),
             ComponentType::class => $this->strategy->getPhpTypeReferenceForComponentType($type, $typeReferenceNode),
             EnumType::class => $this->strategy->getPhpTypeReferenceForEnumType($type, $typeReferenceNode),
             StructType::class => $this->strategy->getPhpTypeReferenceForStructType($type, $typeReferenceNode),
+            UnionType::class => throw new \Exception("There is no such thing as nested unions, think again."),
             default => $this->strategy->getPhpTypeReferenceForCustomType($type, $typeReferenceNode)
         };
+    }
 
-        return $typeReferenceNode->isOptional
-            ? match ($phpTypeReference) {
-                'int|float' => 'null|int|float',
-                default => '?' . $phpTypeReference
-            }
-            : $phpTypeReference;
+    private function transpileNullableType(TypeInterface $type, TypeReferenceNode $typeReferenceNode): string
+    {
+        if ($type->is(NumberType::get())) {
+            return 'null|int|float';
+        }
+        return '?' . $this->transpileNonUnionType($type, $typeReferenceNode);
     }
 }

src/TypeSystem/Resolver/TernaryOperation/TernaryOperationTypeResolver.php

@@ -23,9 +23,12 @@
 namespace PackageFactory\ComponentEngine\TypeSystem\Resolver\TernaryOperation;
 
 use PackageFactory\ComponentEngine\Parser\Ast\BooleanLiteralNode;
+use PackageFactory\ComponentEngine\Parser\Ast\IdentifierNode;
 use PackageFactory\ComponentEngine\Parser\Ast\TernaryOperationNode;
 use PackageFactory\ComponentEngine\TypeSystem\Resolver\Expression\ExpressionTypeResolver;
+use PackageFactory\ComponentEngine\TypeSystem\Scope\ShallowScope\ShallowScope;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
@@ -41,14 +44,39 @@ public function resolveTypeOf(TernaryOperationNode $ternaryOperationNode): TypeI
         $expressionTypeResolver = new ExpressionTypeResolver(
             scope: $this->scope
         );
-        $conditionNode = $ternaryOperationNode->condition->root;
+        $conditionNode = $ternaryOperationNode->condition;
 
-        if ($conditionNode instanceof BooleanLiteralNode) {
-            return $conditionNode->value
+        $rootType = $expressionTypeResolver->resolveTypeOf($conditionNode);
+
+        if ($conditionNode->root instanceof BooleanLiteralNode) {
+            return $conditionNode->root->value
                 ? $expressionTypeResolver->resolveTypeOf($ternaryOperationNode->true)
                 : $expressionTypeResolver->resolveTypeOf($ternaryOperationNode->false);
         }
 
+        if ($conditionNode->root instanceof IdentifierNode && $rootType instanceof UnionType && $rootType->isNullable()) {
+            $trueExpressionTypeResolver = new ExpressionTypeResolver(
+                scope: new ShallowScope(
+                    $conditionNode->root->value,
+                    $rootType->withoutNullable(),
+                    $this->scope
+                )
+            );
+
+            $falseExpressionTypeResolver = new ExpressionTypeResolver(
+                scope: new ShallowScope(
+                    $conditionNode->root->value,
+                    NullType::get(),
+                    $this->scope
+                )
+            );
+
+            return UnionType::of(
+                $trueExpressionTypeResolver->resolveTypeOf($ternaryOperationNode->true),
+                $falseExpressionTypeResolver->resolveTypeOf($ternaryOperationNode->false)
+            );
+        }
+
         return UnionType::of(
             $expressionTypeResolver->resolveTypeOf($ternaryOperationNode->true),
             $expressionTypeResolver->resolveTypeOf($ternaryOperationNode->false)

src/TypeSystem/Scope/GlobalScope/GlobalScope.php

@@ -22,13 +22,14 @@
 
 namespace PackageFactory\ComponentEngine\TypeSystem\Scope\GlobalScope;
 
-use PackageFactory\ComponentEngine\Parser\Ast\ComponentDeclarationNode;
 use PackageFactory\ComponentEngine\Parser\Ast\TypeReferenceNode;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 use PackageFactory\ComponentEngine\TypeSystem\Type\BooleanType\BooleanType;
+use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\NumberType\NumberType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\SlotType\SlotType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\StringType\StringType;
+use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
 final class GlobalScope implements ScopeInterface
@@ -51,12 +52,16 @@ public function lookupTypeFor(string $name): ?TypeInterface
 
     public function resolveTypeReference(TypeReferenceNode $typeReferenceNode): TypeInterface
     {
-        return match ($typeReferenceNode->name) {
+        $type = match ($typeReferenceNode->name) {
             'string' => StringType::get(),
             'number' => NumberType::get(),
             'boolean' => BooleanType::get(),
             'slot' => SlotType::get(),
             default => throw new \Exception('@TODO: Unknown Type ' . $typeReferenceNode->name)
         };
+        if ($typeReferenceNode->isOptional) {
+            $type = UnionType::of($type, NullType::get());
+        }
+        return $type;
     }
 }

src/TypeSystem/Scope/ModuleScope/ModuleScope.php

@@ -26,6 +26,8 @@
 use PackageFactory\ComponentEngine\Parser\Ast\ModuleNode;
 use PackageFactory\ComponentEngine\Parser\Ast\TypeReferenceNode;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
+use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
 final class ModuleScope implements ScopeInterface
@@ -45,7 +47,11 @@ public function lookupTypeFor(string $name): ?TypeInterface
     public function resolveTypeReference(TypeReferenceNode $typeReferenceNode): TypeInterface
     {
         if ($importNode = $this->moduleNode->imports->get($typeReferenceNode->name)) {
-            return $this->loader->resolveTypeOfImport($importNode);
+            $type = $this->loader->resolveTypeOfImport($importNode);
+            if ($typeReferenceNode->isOptional) {
+                $type = UnionType::of($type, NullType::get());
+            }
+            return $type;
         }
 
         if ($this->parentScope) {

src/TypeSystem/Scope/ShallowScope/ShallowScope.php

@@ -0,0 +1,51 @@
+<?php
+
+/**
+ * PackageFactory.ComponentEngine - Universal View Components for PHP
+ *   Copyright (C) 2022 Contributors of PackageFactory.ComponentEngine
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare(strict_types=1);
+
+namespace PackageFactory\ComponentEngine\TypeSystem\Scope\ShallowScope;
+
+use PackageFactory\ComponentEngine\Parser\Ast\TypeReferenceNode;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
+
+final class ShallowScope implements ScopeInterface
+{
+    public function __construct(
+        private readonly string $overriddenName,
+        private readonly TypeInterface $overriddenType,
+        private readonly ScopeInterface $parentScope
+    ) {
+    }
+
+    public function lookupTypeFor(string $name): ?TypeInterface
+    {
+        if ($this->overriddenName === $name) {
+            return $this->overriddenType;
+        }
+
+        return $this->parentScope->lookupTypeFor($name);
+    }
+
+    public function resolveTypeReference(TypeReferenceNode $typeReferenceNode): TypeInterface
+    {
+        return $this->parentScope->resolveTypeReference($typeReferenceNode);
+    }
+}

src/TypeSystem/Type/UnionType/UnionType.php

@@ -22,17 +22,24 @@
 
 namespace PackageFactory\ComponentEngine\TypeSystem\Type\UnionType;
 
+use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
-final class UnionType implements TypeInterface
+/**
+ * @implements \IteratorAggregate<int, TypeInterface>
+ */
+final class UnionType implements TypeInterface, \IteratorAggregate, \Countable
 {
     /**
      * @var TypeInterface[]
      */
-    private array $members;
+    private readonly array $members;
 
     private function __construct(TypeInterface ...$members)
     {
+        if (count($members) < 1) {
+            throw new \Exception('UnionType can only hold more than one different members');
+        }
         $this->members = $members;
     }
 
@@ -53,7 +60,32 @@ public static function of(TypeInterface ...$members): TypeInterface
             return $uniqueMembers[0];
         }
 
-        return new self(...$members);
+        return new self(...$uniqueMembers);
+    }
+
+    public function isNullable(): bool
+    {
+        foreach ($this->members as $member) {
+            if ($member->is(NullType::get())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public function withoutNullable(): TypeInterface
+    {
+        $nonNullMembers = [];
+        foreach ($this->members as $member) {
+            if ($member->is(NullType::get())) {
+                continue;
+            }
+            $nonNullMembers[] = $member;
+        }
+        if (count($nonNullMembers) === 1) {
+            return $nonNullMembers[0];
+        }
+        return self::of(...$nonNullMembers);
     }
 
     public function is(TypeInterface $other): bool
@@ -67,15 +99,26 @@ public function is(TypeInterface $other): bool
                         break;
                     }
                 }
-    
+
                 if (!$match) {
                     return false;
                 }
             }
-    
+
             return true;
         } else {
             return false;
         }
     }
+
+    /** @return \ArrayIterator<int, TypeInterface> */
+    public function getIterator(): \ArrayIterator
+    {
+        return new \ArrayIterator($this->members);
+    }
+
+    public function count(): int
+    {
+        return count($this->members);
+    }
 }

test/Unit/TypeSystem/Resolver/TernaryOperation/TernaryOperationTypeResolverTest.php

@@ -26,6 +26,7 @@
 use PackageFactory\ComponentEngine\Parser\Ast\TernaryOperationNode;
 use PackageFactory\ComponentEngine\Test\Unit\TypeSystem\Scope\Fixtures\DummyScope;
 use PackageFactory\ComponentEngine\TypeSystem\Resolver\TernaryOperation\TernaryOperationTypeResolver;
+use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\NumberType\NumberType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\StringType\StringType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
@@ -46,7 +47,13 @@ public function ternaryOperationExamples(): array
             '1 < 2 ? variableOfTypeString : variableOfTypeNumber' => [
                 '1 < 2 ? variableOfTypeString : variableOfTypeNumber', 
                 UnionType::of(NumberType::get(), StringType::get())
-            ]
+            ],
+            'nullableString ? nullableString : "fallback"' => [
+                'nullableString ? nullableString : "fallback"', StringType::get()
+            ],
+            'nullableString ? null : nullableString' => [
+                'nullableString ? null : nullableString', NullType::get()
+            ],
         ];
     }
 
@@ -62,6 +69,7 @@ public function resolvesTernaryOperationToResultingType(string $ternaryExpressio
         $scope = new DummyScope([
             'variableOfTypeString' => StringType::get(),
             'variableOfTypeNumber' => NumberType::get(),
+            'nullableString' => UnionType::of(StringType::get(), NullType::get())
         ]);
         $ternaryOperationTypeResolver = new TernaryOperationTypeResolver(
             scope: $scope

test/Unit/TypeSystem/Scope/Fixtures/DummyScope.php

@@ -24,6 +24,8 @@
 
 use PackageFactory\ComponentEngine\Parser\Ast\TypeReferenceNode;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
+use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
 final class DummyScope implements ScopeInterface
@@ -46,6 +48,9 @@ public function lookupTypeFor(string $name): ?TypeInterface
     public function resolveTypeReference(TypeReferenceNode $typeReferenceNode): TypeInterface
     {
         if ($type = $this->typeNameToTypeMap[$typeReferenceNode->name] ?? null) {
+            if ($typeReferenceNode->isOptional) {
+                $type = UnionType::of($type, NullType::get());
+            }
             return $type;
         }