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,41 @@ 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 (count($unionType) === 2 && $unionType->containsNull()) {
+            $typeWithoutNull = $unionType->withoutNull();
+            return $this->transpileNullableType($typeWithoutNull, $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 $typeWithoutNull, TypeReferenceNode $typeReferenceNode): string
+    {
+        $phpTypeWithoutNull = $this->transpileNonUnionType($typeWithoutNull, $typeReferenceNode);
+        return (str_contains($phpTypeWithoutNull, '|') ? 'null|' : '?') . $phpTypeWithoutNull;
     }
 }

src/TypeSystem/Inferrer/InferredTypes.php

@@ -0,0 +1,72 @@
+<?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\Inferrer;
+
+use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
+
+class InferredTypes
+{
+    /**
+     * Map of identifierName to the corresponding inferred type
+     * @var array<string,TypeInterface>
+     */
+    private readonly array $types;
+
+    private function __construct(
+        TypeInterface ...$types
+    ) {
+        assert(self::isAssociativeArray($types), '$types must be an associative array');
+        $this->types = $types;
+    }
+
+    public static function empty(): self
+    {
+        return new self();
+    }
+
+    public static function fromType(string $identifierName, TypeInterface $type): self
+    {
+        return new self(...[$identifierName => $type]);
+    }
+
+    public function getType(string $identifierName): ?TypeInterface
+    {
+        return $this->types[$identifierName] ?? null;
+    }
+
+    /**
+     * @template T
+     * @param array<string|int,T> $array
+     * @phpstan-assert-if-true array<string,T> $array
+     */
+    private static function isAssociativeArray(array $array): bool
+    {
+        foreach ($array as $key => $value) {
+            if (is_string($key)) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+}

src/TypeSystem/Inferrer/TypeInferrer.php

@@ -0,0 +1,97 @@
+<?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\Inferrer;
+
+use PackageFactory\ComponentEngine\Definition\BinaryOperator;
+use PackageFactory\ComponentEngine\Parser\Ast\BinaryOperationNode;
+use PackageFactory\ComponentEngine\Parser\Ast\ExpressionNode;
+use PackageFactory\ComponentEngine\Parser\Ast\IdentifierNode;
+use PackageFactory\ComponentEngine\Parser\Ast\NullLiteralNode;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+
+/**
+ * This class handles the analysis of identifier types that are used in a condition
+ * and based on the requested branch: truthy or falsy, will predict the types a variable will have in the respective branch
+ * so it matches the expected runtime behaviour
+ *
+ * For example given this expression: `nullableString ? "nullableString is not null" : "nullableString is null"` based on the condition `nullableString`
+ * It will infer that in the truthy context nullableString is a string while in the falsy context it will infer that it is a null
+ *
+ * The structure is partially inspired by phpstan
+ * https://github.com/phpstan/phpstan-src/blob/07bb4aa2d5e39dafa78f56c5df132c763c2d1b67/src/Analyser/TypeSpecifier.php#L111
+ */
+class TypeInferrer
+{
+    public function __construct(
+        private readonly ScopeInterface $scope
+    ) {
+    }
+
+    public function inferTypesInCondition(ExpressionNode $conditionNode, TypeInferrerContext $context): InferredTypes
+    {
+        if ($conditionNode->root instanceof IdentifierNode) {
+            $type = $this->scope->lookupTypeFor($conditionNode->root->value);
+            if (!$type) {
+                return InferredTypes::empty();
+            }
+            // case `nullableString ? "nullableString is not null" : "nullableString is null"`
+            return InferredTypes::fromType($conditionNode->root->value, $context->narrowDownType($type));
+        }
+
+        if (($binaryOperationNode = $conditionNode->root) instanceof BinaryOperationNode) {
+            // cases
+            // `nullableString === null ? "nullableString is null" : "nullableString is not null"`
+            // `nullableString !== null ? "nullableString is not null" : "nullableString is null"`
+            if (count($binaryOperationNode->operands->rest) !== 1) {
+                return InferredTypes::empty();
+            }
+            $first = $binaryOperationNode->operands->first;
+            $second = $binaryOperationNode->operands->rest[0];
+
+            $comparedIdentifierValueToNull = match (true) {
+                // case `nullableString === null`
+                $first->root instanceof IdentifierNode && $second->root instanceof NullLiteralNode => $first->root->value,
+                // yodas case `null === nullableString`
+                $first->root instanceof NullLiteralNode && $second->root instanceof IdentifierNode => $second->root->value,
+                default => null
+            };
+
+            if ($comparedIdentifierValueToNull === null) {
+                return InferredTypes::empty();
+            }
+            $type = $this->scope->lookupTypeFor($comparedIdentifierValueToNull);
+            if (!$type) {
+                return InferredTypes::empty();
+            }
+
+            if ($binaryOperationNode->operator === BinaryOperator::EQUAL) {
+                return InferredTypes::fromType($comparedIdentifierValueToNull, $context->negate()->narrowDownType($type));
+            }
+            if ($binaryOperationNode->operator === BinaryOperator::NOT_EQUAL) {
+                return InferredTypes::fromType($comparedIdentifierValueToNull, $context->narrowDownType($type));
+            }
+        }
+
+        return InferredTypes::empty();
+    }
+}

src/TypeSystem/Inferrer/TypeInferrerContext.php

@@ -0,0 +1,53 @@
+<?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\Inferrer;
+
+use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
+use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
+use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
+
+enum TypeInferrerContext
+{
+    case TRUTHY;
+
+    case FALSY;
+
+    public function negate(): self
+    {
+        return match ($this) {
+            self::TRUTHY => self::FALSY,
+            self::FALSY => self::TRUTHY
+        };
+    }
+
+    public function narrowDownType(TypeInterface $type): TypeInterface
+    {
+        if (!$type instanceof UnionType || !$type->containsNull()) {
+            return $type;
+        }
+        return match ($this) {
+            self::TRUTHY => $type->withoutNull(),
+            self::FALSY => NullType::get()
+        };
+    }
+}

src/TypeSystem/Resolver/TernaryOperation/TernaryOperationTypeResolver.php

@@ -25,6 +25,7 @@
 use PackageFactory\ComponentEngine\Parser\Ast\BooleanLiteralNode;
 use PackageFactory\ComponentEngine\Parser\Ast\TernaryOperationNode;
 use PackageFactory\ComponentEngine\TypeSystem\Resolver\Expression\ExpressionTypeResolver;
+use PackageFactory\ComponentEngine\TypeSystem\Scope\TernaryBranchScope\TernaryBranchScope;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
@@ -38,20 +39,29 @@ public function __construct(
 
     public function resolveTypeOf(TernaryOperationNode $ternaryOperationNode): TypeInterface
     {
-        $expressionTypeResolver = new ExpressionTypeResolver(
-            scope: $this->scope
+        $trueExpressionTypeResolver = new ExpressionTypeResolver(
+            scope: TernaryBranchScope::forTruthyBranch(
+                $ternaryOperationNode->condition,
+                $this->scope
+            )
         );
-        $conditionNode = $ternaryOperationNode->condition->root;
 
-        if ($conditionNode instanceof BooleanLiteralNode) {
-            return $conditionNode->value
-                ? $expressionTypeResolver->resolveTypeOf($ternaryOperationNode->true)
-                : $expressionTypeResolver->resolveTypeOf($ternaryOperationNode->false);
+        $falseExpressionTypeResolver = new ExpressionTypeResolver(
+            scope: TernaryBranchScope::forFalsyBranch(
+                $ternaryOperationNode->condition,
+                $this->scope
+            )
+        );
+
+        if ($ternaryOperationNode->condition->root instanceof BooleanLiteralNode) {
+            return $ternaryOperationNode->condition->root->value
+                ? $trueExpressionTypeResolver->resolveTypeOf($ternaryOperationNode->true)
+                : $falseExpressionTypeResolver->resolveTypeOf($ternaryOperationNode->false);
         }
 
         return UnionType::of(
-            $expressionTypeResolver->resolveTypeOf($ternaryOperationNode->true),
-            $expressionTypeResolver->resolveTypeOf($ternaryOperationNode->false)
+            $trueExpressionTypeResolver->resolveTypeOf($ternaryOperationNode->true),
+            $falseExpressionTypeResolver->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) {