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

mhsdesign · mhsdesign · commit 138e5b518855 · 2023-04-26T07:57:32.000+02:00
diff --git a/src/TypeSystem/Narrower/ExpressionTypeNarrower.php b/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 $conditionNode, TypeNarrowerContext $context): NarrowedTypes
     {
         if ($conditionNode->root instanceof IdentifierNode) {
             $type = $this->scope->lookupTypeFor($conditionNode->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($conditionNode->root->value, $context->narrowType($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();
+                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();
     }
 }
diff --git a/src/TypeSystem/Narrower/NarrowedTypes.php b/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;
-    }
 }
diff --git a/src/TypeSystem/Narrower/TypeNarrowerContext.php b/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;
diff --git a/src/TypeSystem/Scope/TernaryBranchScope/TernaryBranchScope.php b/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
         );
     }

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@`
`20`	`20`
`21`	`21`	`declare(strict_types=1);`
`22`	`22`
`23`		`-namespace PackageFactory\ComponentEngine\TypeSystem\Inferrer;`
	`23`	`+namespace PackageFactory\ComponentEngine\TypeSystem\Narrower;`
`24`	`24`
`25`	`25`	`use PackageFactory\ComponentEngine\Definition\BinaryOperator;`
`26`	`26`	`use PackageFactory\ComponentEngine\Parser\Ast\BinaryOperationNode;`
`@@ -40,30 +40,30 @@`
`40`	`40`	`* The structure is partially inspired by phpstan`
`41`	`41`	`* https://github.com/phpstan/phpstan-src/blob/07bb4aa2d5e39dafa78f56c5df132c763c2d1b67/src/Analyser/TypeSpecifier.php#L111`
`42`	`42`	`*/`
`43`		`-class TypeInferrer`
	`43`	`+class ExpressionTypeNarrower`
`44`	`44`	`{`
`45`	`45`	`public function __construct(`
`46`	`46`	`private readonly ScopeInterface $scope`
`47`	`47`	`) {`
`48`	`48`	`}`
`49`	`49`
`50`		`- public function inferTypesInCondition(ExpressionNode $conditionNode, TypeInferrerContext $context): InferredTypes`
	`50`	`+ public function narrowTypesOfSymbolsIn(ExpressionNode $conditionNode, TypeNarrowerContext $context): NarrowedTypes`
`51`	`51`	`{`
`52`	`52`	`if ($conditionNode->root instanceof IdentifierNode) {`
`53`	`53`	`$type = $this->scope->lookupTypeFor($conditionNode->root->value);`
`54`	`54`	`if (!$type) {`
`55`		`- return InferredTypes::empty();`
	`55`	`+ return NarrowedTypes::empty();`
`56`	`56`	`}`
`57`	`57`	// case `nullableString ? "nullableString is not null" : "nullableString is null"`
`58`		`- return InferredTypes::fromType($conditionNode->root->value, $context->narrowDownType($type));`
	`58`	`+ return NarrowedTypes::fromEntry($conditionNode->root->value, $context->narrowType($type));`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`if (($binaryOperationNode = $conditionNode->root) instanceof BinaryOperationNode) {`
`62`	`62`	`// cases`
`63`	`63`	// `nullableString === null ? "nullableString is null" : "nullableString is not null"`
`64`	`64`	// `nullableString !== null ? "nullableString is not null" : "nullableString is null"`
`65`	`65`	`if (count($binaryOperationNode->operands->rest) !== 1) {`
`66`		`- return InferredTypes::empty();`
	`66`	`+ return NarrowedTypes::empty();`
`67`	`67`	`}`
`68`	`68`	`$first = $binaryOperationNode->operands->first;`
`69`	`69`	`$second = $binaryOperationNode->operands->rest[0];`
`@@ -77,21 +77,21 @@ public function inferTypesInCondition(ExpressionNode $conditionNode, TypeInferre`
`77`	`77`	`};`
`78`	`78`
`79`	`79`	`if ($comparedIdentifierValueToNull === null) {`
`80`		`- return InferredTypes::empty();`
	`80`	`+ return NarrowedTypes::empty();`
`81`	`81`	`}`
`82`	`82`	`$type = $this->scope->lookupTypeFor($comparedIdentifierValueToNull);`
`83`	`83`	`if (!$type) {`
`84`		`- return InferredTypes::empty();`
	`84`	`+ return NarrowedTypes::empty();`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`if ($binaryOperationNode->operator === BinaryOperator::EQUAL) {`
`88`		`- return InferredTypes::fromType($comparedIdentifierValueToNull, $context->negate()->narrowDownType($type));`
	`88`	`+ return NarrowedTypes::fromEntry($comparedIdentifierValueToNull, $context->negate()->narrowType($type));`
`89`	`89`	`}`
`90`	`90`	`if ($binaryOperationNode->operator === BinaryOperator::NOT_EQUAL) {`
`91`		`- return InferredTypes::fromType($comparedIdentifierValueToNull, $context->narrowDownType($type));`
	`91`	`+ return NarrowedTypes::fromEntry($comparedIdentifierValueToNull, $context->narrowType($type));`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`		`- return InferredTypes::empty();`
	`95`	`+ return NarrowedTypes::empty();`
`96`	`96`	`}`
`97`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,11 @@`
`20`	`20`
`21`	`21`	`declare(strict_types=1);`
`22`	`22`
`23`		`-namespace PackageFactory\ComponentEngine\TypeSystem\Inferrer;`
	`23`	`+namespace PackageFactory\ComponentEngine\TypeSystem\Narrower;`
`24`	`24`
`25`	`25`	`use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;`
`26`	`26`
`27`		`-class InferredTypes`
	`27`	`+class NarrowedTypes`
`28`	`28`	`{`
`29`	`29`	`/**`
`30`	`30`	`* Map of identifierName to the corresponding inferred type`
`@@ -35,7 +35,7 @@ class InferredTypes`
`35`	`35`	`private function __construct(`
`36`	`36`	`TypeInterface ...$types`
`37`	`37`	`) {`
`38`		`- assert(self::isAssociativeArray($types), '$types must be an associative array');`
	`38`	`+ /** @var array<string,TypeInterface> $types */`
`39`	`39`	`$this->types = $types;`
`40`	`40`	`}`
`41`	`41`
`@@ -44,7 +44,7 @@ public static function empty(): self`
`44`	`44`	`return new self();`
`45`	`45`	`}`
`46`	`46`
`47`		`- public static function fromType(string $identifierName, TypeInterface $type): self`
	`47`	`+ public static function fromEntry(string $identifierName, TypeInterface $type): self`
`48`	`48`	`{`
`49`	`49`	`return new self(...[$identifierName => $type]);`
`50`	`50`	`}`
`@@ -53,20 +53,4 @@ public function getType(string $identifierName): ?TypeInterface`
`53`	`53`	`{`
`54`	`54`	`return $this->types[$identifierName] ?? null;`
`55`	`55`	`}`
`56`		`-`
`57`		`- /**`
`58`		`- * @template T`
`59`		`- * @param array<string\|int,T> $array`
`60`		`- * @phpstan-assert-if-true array<string,T> $array`
`61`		`- */`
`62`		`- private static function isAssociativeArray(array $array): bool`
`63`		`- {`
`64`		`- foreach ($array as $key => $value) {`
`65`		`- if (is_string($key)) {`
`66`		`- continue;`
`67`		`- }`
`68`		`- return false;`
`69`		`- }`
`70`		`- return true;`
`71`		`- }`
`72`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,13 +20,13 @@`
`20`	`20`
`21`	`21`	`declare(strict_types=1);`
`22`	`22`
`23`		`-namespace PackageFactory\ComponentEngine\TypeSystem\Inferrer;`
	`23`	`+namespace PackageFactory\ComponentEngine\TypeSystem\Narrower;`
`24`	`24`
`25`	`25`	`use PackageFactory\ComponentEngine\TypeSystem\Type\NullType\NullType;`
`26`	`26`	`use PackageFactory\ComponentEngine\TypeSystem\Type\UnionType\UnionType;`
`27`	`27`	`use PackageFactory\ComponentEngine\TypeSystem\TypeInterface;`
`28`	`28`
`29`		`-enum TypeInferrerContext`
	`29`	`+enum TypeNarrowerContext`
`30`	`30`	`{`
`31`	`31`	`case TRUTHY;`
`32`	`32`
`@@ -40,7 +40,7 @@ public function negate(): self`
`40`	`40`	`};`
`41`	`41`	`}`
`42`	`42`
`43`		`- public function narrowDownType(TypeInterface $type): TypeInterface`
	`43`	`+ public function narrowType(TypeInterface $type): TypeInterface`
`44`	`44`	`{`
`45`	`45`	`if (!$type instanceof UnionType \|\| !$type->containsNull()) {`
`46`	`46`	`return $type;`