TASK: Narrower null comparison against any expression that resolves to null

Author: mhsdesign

src/TypeSystem/Narrower/ExpressionTypeNarrower.php

@@ -22,13 +22,13 @@
 
 namespace PackageFactory\ComponentEngine\TypeSystem\Narrower;
 
-use PackageFactory\ComponentEngine\Definition\BinaryOperator;
 use PackageFactory\ComponentEngine\Parser\Ast\BinaryOperationNode;
 use PackageFactory\ComponentEngine\Parser\Ast\BooleanLiteralNode;
 use PackageFactory\ComponentEngine\Parser\Ast\ExpressionNode;
 use PackageFactory\ComponentEngine\Parser\Ast\IdentifierNode;
-use PackageFactory\ComponentEngine\Parser\Ast\NullLiteralNode;
+use PackageFactory\ComponentEngine\TypeSystem\Resolver\Expression\ExpressionTypeResolver;
 use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
 
 /**
  * This class handles the analysis of identifier types that are used in a condition
@@ -68,23 +68,13 @@ public function narrowTypesOfSymbolsIn(ExpressionNode $expressionNode, TypeNarro
             $second = $binaryOperationNode->operands->rest[0];
 
             if (
-                ($first->root instanceof BooleanLiteralNode
-                    && ($boolean = $first->root) instanceof BooleanLiteralNode
-                    // @phpstan-ignore-next-line
-                    && $other = $second
-                ) || ($second->root instanceof BooleanLiteralNode
-                    && ($boolean = $second->root) instanceof BooleanLiteralNode
-                    // @phpstan-ignore-next-line
-                    && $other = $first
+                (($boolean = $first->root) instanceof BooleanLiteralNode
+                    && $other = $second // @phpstan-ignore-line
+                ) || (($boolean = $second->root) instanceof BooleanLiteralNode
+                    && $other = $first // @phpstan-ignore-line
                 )
             ) {
-                $contextBasedOnOperator = match ($binaryOperationNode->operator) {
-                    BinaryOperator::EQUAL => $context,
-                    BinaryOperator::NOT_EQUAL => $context->negate(),
-                    default => null,
-                };
-
-                if (!$contextBasedOnOperator) {
+                if (!$contextBasedOnOperator = $context->basedOnBinaryOperator($binaryOperationNode->operator)) {
                     return NarrowedTypes::empty();
                 }
 
@@ -94,30 +84,30 @@ public function narrowTypesOfSymbolsIn(ExpressionNode $expressionNode, TypeNarro
                 );
             }
 
-            // cases
-            // `nullableString === null ? "nullableString is null" : "nullableString is not null"`
-            // `nullableString !== null ? "nullableString is not null" : "nullableString is null"`
-            $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
-            };
+            $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
+                )
+            ) {
+                if (!$other->root instanceof IdentifierNode) {
+                    return NarrowedTypes::empty();
+                }
+                $type = $this->scope->lookupTypeFor($other->root->value);
+                if (!$type) {
+                    return NarrowedTypes::empty();
+                }
 
-            if ($comparedIdentifierValueToNull === null) {
-                return NarrowedTypes::empty();
-            }
-            $type = $this->scope->lookupTypeFor($comparedIdentifierValueToNull);
-            if (!$type) {
-                return NarrowedTypes::empty();
-            }
+                if (!$contextBasedOnOperator = $context->basedOnBinaryOperator($binaryOperationNode->operator)) {
+                    return NarrowedTypes::empty();
+                }
 
-            if ($binaryOperationNode->operator === BinaryOperator::EQUAL) {
-                return NarrowedTypes::fromEntry($comparedIdentifierValueToNull, $context->negate()->narrowType($type));
-            }
-            if ($binaryOperationNode->operator === BinaryOperator::NOT_EQUAL) {
-                return NarrowedTypes::fromEntry($comparedIdentifierValueToNull, $context->narrowType($type));
+                return NarrowedTypes::fromEntry(
+                    $other->root->value,
+                    $contextBasedOnOperator->negate()->narrowType($type)
+                );
             }
         }
 

src/TypeSystem/Narrower/TypeNarrowerContext.php

@@ -22,6 +22,7 @@
 
 namespace PackageFactory\ComponentEngine\TypeSystem\Narrower;
 
+use PackageFactory\ComponentEngine\Definition\BinaryOperator;
 use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
@@ -40,6 +41,15 @@ public function negate(): self
         };
     }
 
+    public function basedOnBinaryOperator(BinaryOperator $operator): ?self
+    {
+        return match ($operator) {
+            BinaryOperator::EQUAL => $this,
+            BinaryOperator::NOT_EQUAL => $this->negate(),
+            default => null,
+        };
+    }
+
     public function narrowType(TypeInterface $type): TypeInterface
     {
         if (!$type instanceof UnionType || !$type->containsNull()) {

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

@@ -84,6 +84,10 @@ public function ternaryOperationExamples(): array
             'true !== (nullableString === null) ? nullableString : ""' => [
                 'true !== (nullableString === null) ? nullableString : ""', StringType::get()
             ],
+
+            'nullableString === variableOfTypeNull ? "" : nullableString' => [
+                'nullableString === variableOfTypeNull ? "" : nullableString', StringType::get()
+            ],
         ];
     }
 
@@ -99,6 +103,7 @@ public function resolvesTernaryOperationToResultingType(string $ternaryExpressio
         $scope = new DummyScope([
             'variableOfTypeString' => StringType::get(),
             'variableOfTypeNumber' => NumberType::get(),
+            'variableOfTypeNull' => NullType::get(),
             'nullableString' => UnionType::of(StringType::get(), NullType::get())
         ]);
         $ternaryOperationTypeResolver = new TernaryOperationTypeResolver(