WIP: Ternary Expression TypeNarrower for Nullables

src/TypeSystem/Narrower/Expression/ExpressionTypeNarrower.php

@@ -28,7 +28,7 @@
 use PackageFactory\ComponentEngine\Parser\Ast\ExpressionNode;
 use PackageFactory\ComponentEngine\Parser\Ast\IdentifierNode;
 use PackageFactory\ComponentEngine\TypeSystem\Narrower\NarrowedTypes;
-use PackageFactory\ComponentEngine\TypeSystem\Narrower\TypeNarrowerContext;
+use PackageFactory\ComponentEngine\TypeSystem\Narrower\Truthiness;
 use PackageFactory\ComponentEngine\TypeSystem\Resolver\Expression\ExpressionTypeResolver;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
@@ -38,75 +38,84 @@
  * 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
+ * For example given this expression: `nullableString ? nullableString : "fallback"` 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 null.
+ * In the above case the ternary expression will resolve to a string.
  *
  * The structure is partially inspired by phpstan
  * https://github.com/phpstan/phpstan-src/blob/07bb4aa2d5e39dafa78f56c5df132c763c2d1b67/src/Analyser/TypeSpecifier.php#L111
  */
 class ExpressionTypeNarrower
 {
-    public function __construct(
-        private readonly ScopeInterface $scope
+    private function __construct(
+        private readonly ScopeInterface $scope,
+        private readonly Truthiness $assumedTruthiness
     ) {
     }
 
-    public function narrowTypesOfSymbolsIn(ExpressionNode $expressionNode, TypeNarrowerContext $context): NarrowedTypes
+    public static function forTruthy(ScopeInterface $scope): self
+    {
+        return new self($scope, Truthiness::TRUTHY);
+    }
+
+    public static function forFalsy(ScopeInterface $scope): self
+    {
+        return new self($scope, Truthiness::FALSY);
+    }
+
+    public function narrowTypesOfSymbolsIn(ExpressionNode $expressionNode): NarrowedTypes
     {
         if ($expressionNode->root instanceof IdentifierNode) {
             $type = $this->scope->lookupTypeFor($expressionNode->root->value);
             if (!$type) {
                 return NarrowedTypes::empty();
             }
             // case `nullableString ? "nullableString is not null" : "nullableString is null"`
-            return NarrowedTypes::fromEntry($expressionNode->root->value, $context->narrowType($type));
+            return NarrowedTypes::fromEntry($expressionNode->root->value, $this->assumedTruthiness->narrowType($type));
         }
 
         if (($binaryOperationNode = $expressionNode->root) instanceof BinaryOperationNode) {
-            // todo we currently only work with two operands
-            if (count($binaryOperationNode->operands->rest) !== 1) {
-                return NarrowedTypes::empty();
-            }
-            $first = $binaryOperationNode->operands->first;
-            $second = $binaryOperationNode->operands->rest[0];
+            $right = $binaryOperationNode->right;
+            $left = $binaryOperationNode->left;
 
             if (
-                (($boolean = $first->root) instanceof BooleanLiteralNode
-                    && $other = $second // @phpstan-ignore-line
-                ) || (($boolean = $second->root) instanceof BooleanLiteralNode
-                    && $other = $first // @phpstan-ignore-line
+                (($boolean = $right->root) instanceof BooleanLiteralNode
+                    && $other = $left // @phpstan-ignore-line
+                ) || (($boolean = $left->root) instanceof BooleanLiteralNode
+                    && $other = $right // @phpstan-ignore-line
                 )
             ) {
                 switch ($binaryOperationNode->operator) {
                     case BinaryOperator::AND:
-                        if ($boolean->value && $context === TypeNarrowerContext::TRUTHY) {
-                            return $this->narrowTypesOfSymbolsIn($other, $context);
+                        if ($boolean->value && $this->assumedTruthiness === Truthiness::TRUTHY) {
+                            return $this->narrowTypesOfSymbolsIn($other);
                         }
                         break;
                     case BinaryOperator::EQUAL:
                     case BinaryOperator::NOT_EQUAL:
-                        $contextBasedOnOperator = $context->basedOnBinaryOperator($binaryOperationNode->operator);
+                        $contextBasedOnOperator = $this->assumedTruthiness->basedOnBinaryOperator($binaryOperationNode->operator);
                         assert($contextBasedOnOperator !== null);
 
                         if ($other->root instanceof IdentifierNode) {
                             return NarrowedTypes::empty();
                         }
 
-                        return $this->narrowTypesOfSymbolsIn(
-                            $other,
+                        $subNarrower = new self(
+                            $this->scope,
                             $boolean->value ? $contextBasedOnOperator : $contextBasedOnOperator->negate()
                         );
+                        return $subNarrower->narrowTypesOfSymbolsIn($other);
                 }
 
                 return NarrowedTypes::empty();
             }
 
             $expressionTypeResolver = (new ExpressionTypeResolver($this->scope));
             if (
-                ($expressionTypeResolver->resolveTypeOf($first)->is(NullType::get())
-                    && $other = $second // @phpstan-ignore-line
-                ) || ($expressionTypeResolver->resolveTypeOf($second)->is(NullType::get())
-                    && $other = $first // @phpstan-ignore-line
+                ($expressionTypeResolver->resolveTypeOf($right)->is(NullType::get())
+                    && $other = $left // @phpstan-ignore-line
+                ) || ($expressionTypeResolver->resolveTypeOf($left)->is(NullType::get())
+                    && $other = $right // @phpstan-ignore-line
                 )
             ) {
                 if (!$other->root instanceof IdentifierNode) {
@@ -117,7 +126,7 @@ public function narrowTypesOfSymbolsIn(ExpressionNode $expressionNode, TypeNarro
                     return NarrowedTypes::empty();
                 }
 
-                if (!$contextBasedOnOperator = $context->basedOnBinaryOperator($binaryOperationNode->operator)) {
+                if (!$contextBasedOnOperator = $this->assumedTruthiness->basedOnBinaryOperator($binaryOperationNode->operator)) {
                     return NarrowedTypes::empty();
                 }
 

src/TypeSystem/Narrower/TypeNarrowerContext.php → src/TypeSystem/Narrower/Truthiness.php

@@ -27,7 +27,7 @@
 use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
-enum TypeNarrowerContext
+enum Truthiness
 {
     case TRUTHY;
 

src/TypeSystem/Scope/TernaryBranchScope/TernaryBranchScope.php

@@ -26,13 +26,12 @@
 use PackageFactory\ComponentEngine\Parser\Ast\TypeReferenceNode;
 use PackageFactory\ComponentEngine\TypeSystem\Narrower\NarrowedTypes;
 use PackageFactory\ComponentEngine\TypeSystem\Narrower\Expression\ExpressionTypeNarrower;
-use PackageFactory\ComponentEngine\TypeSystem\Narrower\TypeNarrowerContext;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
 final class TernaryBranchScope implements ScopeInterface
 {
-    private function __construct(
+    public function __construct(
         private readonly NarrowedTypes $narrowedTypes,
         private readonly ScopeInterface $parentScope
     ) {
@@ -41,15 +40,15 @@ private function __construct(
     public static function forTruthyBranch(ExpressionNode $conditionNode, ScopeInterface $parentScope): self
     {
         return new self(
-            (new ExpressionTypeNarrower($parentScope))->narrowTypesOfSymbolsIn($conditionNode, TypeNarrowerContext::TRUTHY),
+            ExpressionTypeNarrower::forTruthy($parentScope)->narrowTypesOfSymbolsIn($conditionNode),
             $parentScope
         );
     }
 
     public static function forFalsyBranch(ExpressionNode $conditionNode, ScopeInterface $parentScope): self
     {
         return new self(
-            (new ExpressionTypeNarrower($parentScope))->narrowTypesOfSymbolsIn($conditionNode, TypeNarrowerContext::FALSY),
+            ExpressionTypeNarrower::forFalsy($parentScope)->narrowTypesOfSymbolsIn($conditionNode),
             $parentScope
         );
     }

test/Unit/TypeSystem/Narrower/Expression/ExpressionTypeNarrowerTest.php

@@ -27,7 +27,6 @@
 use PackageFactory\ComponentEngine\Test\Unit\TypeSystem\Scope\Fixtures\DummyScope;
 use PackageFactory\ComponentEngine\TypeSystem\Narrower\Expression\ExpressionTypeNarrower;
 use PackageFactory\ComponentEngine\TypeSystem\Narrower\NarrowedTypes;
-use PackageFactory\ComponentEngine\TypeSystem\Narrower\TypeNarrowerContext;
 use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\StringType\StringType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
@@ -85,7 +84,7 @@ public function narrowedExpressionsExamples(): mixed
             'FALSY:: nullableString && true' => [
                 'nullableString && true',
                 NarrowedTypes::empty(),
-                TypeNarrowerContext::FALSY
+                false
             ],
 
             'nullableString === true' => [
@@ -102,18 +101,20 @@ public function narrowedExpressionsExamples(): mixed
     public function narrowedExpressions(
         string $expressionAsString,
         NarrowedTypes $expectedTypes,
-        TypeNarrowerContext $context = TypeNarrowerContext::TRUTHY
+        bool $truthiness = true
     ): void {
-        $expressionTypeNarrower = new ExpressionTypeNarrower(
-            scope: new DummyScope([
-                'nullableString' => UnionType::of(StringType::get(), NullType::get()),
-                'variableOfTypeNull' => NullType::get()
-            ])
-        );
+        $scope = new DummyScope([
+            'nullableString' => UnionType::of(StringType::get(), NullType::get()),
+            'variableOfTypeNull' => NullType::get()
+        ]);
+
+        $expressionTypeNarrower = $truthiness
+            ? ExpressionTypeNarrower::forTruthy($scope)
+            : ExpressionTypeNarrower::forFalsy($scope);
 
         $expressionNode = ExpressionNode::fromString($expressionAsString);
 
-        $actualTypes = $expressionTypeNarrower->narrowTypesOfSymbolsIn($expressionNode, $context);
+        $actualTypes = $expressionTypeNarrower->narrowTypesOfSymbolsIn($expressionNode);
 
         $this->assertEqualsCanonicalizing(
             $expectedTypes->toArray(),