TASK: Rename Inferrer to Narrower and apply further suggestions from code review

Author: mhsdesign

src/TypeSystem/Inferrer/TypeInferrer.php …stem/Narrower/ExpressionTypeNarrower.phpsrc/TypeSystem/Inferrer/TypeInferrer.php renamed to src/TypeSystem/Narrower/ExpressionTypeNarrower.php src/TypeSystem/Inferrer/TypeInferrer.php renamed to src/TypeSystem/Narrower/ExpressionTypeNarrower.php

@@ -20,7 +20,7 @@
 
 declare(strict_types=1);
 
-namespace PackageFactory\ComponentEngine\TypeSystem\Inferrer;
+namespace PackageFactory\ComponentEngine\TypeSystem\Narrower;
 
 use PackageFactory\ComponentEngine\Definition\BinaryOperator;
 use PackageFactory\ComponentEngine\Parser\Ast\BinaryOperationNode;
@@ -40,30 +40,30 @@
  * The structure is partially inspired by phpstan
  * https://github.com/phpstan/phpstan-src/blob/07bb4aa2d5e39dafa78f56c5df132c763c2d1b67/src/Analyser/TypeSpecifier.php#L111
  */
-class TypeInferrer
+class ExpressionTypeNarrower
 {
     public function __construct(
         private readonly ScopeInterface $scope
     ) {
     }
 
-    public function inferTypesInCondition(ExpressionNode $conditionNode, TypeInferrerContext $context): InferredTypes
+    public function narrowTypesOfSymbolsIn(ExpressionNode $expressionNode, TypeNarrowerContext $context): NarrowedTypes
     {
-        if ($conditionNode->root instanceof IdentifierNode) {
-            $type = $this->scope->lookupTypeFor($conditionNode->root->value);
+        if ($expressionNode->root instanceof IdentifierNode) {
+            $type = $this->scope->lookupTypeFor($expressionNode->root->value);
             if (!$type) {
-                return InferredTypes::empty();
+                return NarrowedTypes::empty();
             }
             // case `nullableString ? "nullableString is not null" : "nullableString is null"`
-            return InferredTypes::fromType($conditionNode->root->value, $context->narrowDownType($type));
+            return NarrowedTypes::fromEntry($expressionNode->root->value, $context->narrowType($type));
         }
 
-        if (($binaryOperationNode = $conditionNode->root) instanceof BinaryOperationNode) {
+        if (($binaryOperationNode = $expressionNode->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();
+                return NarrowedTypes::empty();
             }
             $first = $binaryOperationNode->operands->first;
             $second = $binaryOperationNode->operands->rest[0];
@@ -77,21 +77,21 @@ public function inferTypesInCondition(ExpressionNode $conditionNode, TypeInferre
             };
 
             if ($comparedIdentifierValueToNull === null) {
-                return InferredTypes::empty();
+                return NarrowedTypes::empty();
             }
             $type = $this->scope->lookupTypeFor($comparedIdentifierValueToNull);
             if (!$type) {
-                return InferredTypes::empty();
+                return NarrowedTypes::empty();
             }
 
             if ($binaryOperationNode->operator === BinaryOperator::EQUAL) {
-                return InferredTypes::fromType($comparedIdentifierValueToNull, $context->negate()->narrowDownType($type));
+                return NarrowedTypes::fromEntry($comparedIdentifierValueToNull, $context->negate()->narrowType($type));
             }
             if ($binaryOperationNode->operator === BinaryOperator::NOT_EQUAL) {
-                return InferredTypes::fromType($comparedIdentifierValueToNull, $context->narrowDownType($type));
+                return NarrowedTypes::fromEntry($comparedIdentifierValueToNull, $context->narrowType($type));
             }
         }
 
-        return InferredTypes::empty();
+        return NarrowedTypes::empty();
     }
 }

src/TypeSystem/Inferrer/InferredTypes.php src/TypeSystem/Narrower/NarrowedTypes.phpsrc/TypeSystem/Inferrer/InferredTypes.php renamed to src/TypeSystem/Narrower/NarrowedTypes.php

@@ -20,11 +20,11 @@
 
 declare(strict_types=1);
 
-namespace PackageFactory\ComponentEngine\TypeSystem\Inferrer;
+namespace PackageFactory\ComponentEngine\TypeSystem\Narrower;
 
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
-class InferredTypes
+class NarrowedTypes
 {
     /**
      * Map of identifierName to the corresponding inferred type
@@ -35,7 +35,7 @@ class InferredTypes
     private function __construct(
         TypeInterface ...$types
     ) {
-        assert(self::isAssociativeArray($types), '$types must be an associative array');
+        /** @var array<string,TypeInterface> $types */
         $this->types = $types;
     }
 
@@ -44,7 +44,7 @@ public static function empty(): self
         return new self();
     }
 
-    public static function fromType(string $identifierName, TypeInterface $type): self
+    public static function fromEntry(string $identifierName, TypeInterface $type): self
     {
         return new self(...[$identifierName => $type]);
     }
@@ -53,20 +53,4 @@ 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;
-    }
 }

…eSystem/Inferrer/TypeInferrerContext.php …eSystem/Narrower/TypeNarrowerContext.phpsrc/TypeSystem/Inferrer/TypeInferrerContext.php renamed to src/TypeSystem/Narrower/TypeNarrowerContext.php src/TypeSystem/Inferrer/TypeInferrerContext.php renamed to src/TypeSystem/Narrower/TypeNarrowerContext.php

@@ -20,13 +20,13 @@
 
 declare(strict_types=1);
 
-namespace PackageFactory\ComponentEngine\TypeSystem\Inferrer;
+namespace PackageFactory\ComponentEngine\TypeSystem\Narrower;
 
 use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;
 use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;
 use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;
 
-enum TypeInferrerContext
+enum TypeNarrowerContext
 {
     case TRUTHY;
 
@@ -40,7 +40,7 @@ public function negate(): self
         };
     }
 
-    public function narrowDownType(TypeInterface $type): TypeInterface
+    public function narrowType(TypeInterface $type): TypeInterface
     {
         if (!$type instanceof UnionType || !$type->containsNull()) {
             return $type;

src/TypeSystem/Scope/TernaryBranchScope/TernaryBranchScope.php

@@ -24,32 +24,32 @@
 
 use PackageFactory\ComponentEngine\Parser\Ast\ExpressionNode;
 use PackageFactory\ComponentEngine\Parser\Ast\TypeReferenceNode;
-use PackageFactory\ComponentEngine\TypeSystem\Inferrer\InferredTypes;
-use PackageFactory\ComponentEngine\TypeSystem\Inferrer\TypeInferrer;
-use PackageFactory\ComponentEngine\TypeSystem\Inferrer\TypeInferrerContext;
+use PackageFactory\ComponentEngine\TypeSystem\Narrower\NarrowedTypes;
+use PackageFactory\ComponentEngine\TypeSystem\Narrower\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(
-        private readonly InferredTypes $inferredTypes,
+        private readonly NarrowedTypes $inferredTypes,
         private readonly ScopeInterface $parentScope
     ) {
     }
 
     public static function forTruthyBranch(ExpressionNode $conditionNode, ScopeInterface $parentScope): self
     {
         return new self(
-            (new TypeInferrer($parentScope))->inferTypesInCondition($conditionNode, TypeInferrerContext::TRUTHY),
+            (new ExpressionTypeNarrower($parentScope))->narrowTypesOfSymbolsIn($conditionNode, TypeNarrowerContext::TRUTHY),
             $parentScope
         );
     }
 
     public static function forFalsyBranch(ExpressionNode $conditionNode, ScopeInterface $parentScope): self
     {
         return new self(
-            (new TypeInferrer($parentScope))->inferTypesInCondition($conditionNode, TypeInferrerContext::FALSY),
+            (new ExpressionTypeNarrower($parentScope))->narrowTypesOfSymbolsIn($conditionNode, TypeNarrowerContext::FALSY),
             $parentScope
         );
     }