Split type resolver builtin "resolveWith" method to the external transformer

Author: SerafimArts

libs/parser/src/Traverser/TypeMapVisitor.php

@@ -8,6 +8,7 @@
 use TypeLang\Node\Node;
 use TypeLang\Node\Type\CallableTypeNode;
 use TypeLang\Node\Type\ClassConstMaskNode;
+use TypeLang\Node\Type\ClassConstNode;
 use TypeLang\Node\Type\ConstMaskNode;
 use TypeLang\Node\Type\NamedTypeNode;
 
@@ -41,6 +42,7 @@ public function enter(Node $node): ?Command
 
                 return null;
 
+            case $node instanceof ClassConstNode:
             case $node instanceof ClassConstMaskNode:
                 $node->class = $this->map($node->class);
 

libs/parser/src/TypeResolver.php

@@ -4,77 +4,15 @@
 
 namespace TypeLang\Parser;
 
-use TypeLang\Node\Name;
 use TypeLang\Node\Type\TypeNode;
 use TypeLang\Parser\Traverser\TypeMapVisitor;
 
 final class TypeResolver implements TypeResolverInterface
 {
     public function resolve(TypeNode $type, callable $transform): TypeNode
     {
-        Traverser::through(
-            visitor: new TypeMapVisitor($transform(...)),
-            nodes: [$type],
-        );
+        Traverser::through(new TypeMapVisitor($transform(...)), [$type]);
 
         return $type;
     }
-
-    /**
-     * Use for example for code like this:
-     * ```php
-     *  use TypeLang\Parser\Node;
-     *  use TypeLang\Parser\Exception as Error;
-     *
-     *  $parser = new TypeLang\Parser\Parser();
-     *  $result = $parser->parse(<<<'PHP'
-     *      array { Node, Error\SemanticException }
-     *      PHP);
-     *
-     *  $resolver = new \TypeLang\Parser\TypeResolver();
-     *  $result = $resolver->resolveWith($expected, [
-     *      'TypeLang\Parser\Node',                     // use TypeLang\Parser\Node;
-     *      'Error' => 'TypeLang\Parser\Exception',     // use TypeLang\Parser\Exception as Error;
-     *  ]);
-     *
-     *  // Expected Output:
-     *  // > array{
-     *  // >     TypeLang\Parser\Node,
-     *  // >     TypeLang\Parser\Exception\SemanticException
-     *  // > }
-     * ```
-     *
-     * @param array<non-empty-string|array-key, non-empty-string|Name> $replacements
-     */
-    public function resolveWith(TypeNode $type, array $replacements): TypeNode
-    {
-        foreach ($replacements as $key => $replacement) {
-            // normalize value
-            if (\is_string($replacement)) {
-                $replacement = Name::createFromString($replacement);
-            }
-
-            // normalize key
-            if (\is_int($key)) {
-                unset($replacements[$key]);
-
-                $key = $replacement->last->toString();
-            }
-
-            $replacements[\strtolower($key)] = $replacement;
-        }
-
-        /** @var array<non-empty-lowercase-string, Name> $replacements */
-        return $this->resolve($type, static function (Name $name) use ($replacements) {
-            $first = \strtolower($name->first->toString());
-
-            if (isset($replacements[$first])) {
-                $prefix = $replacements[$first];
-
-                return $prefix->mergeWith($name);
-            }
-
-            return null;
-        });
-    }
 }

libs/parser/src/TypeResolver/PhpUseStatementsTransformer.php

@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Parser\TypeResolver;
+
+use TypeLang\Node\Name;
+
+/**
+ * A set of rules for modifying names defined in the `use` statements of PHP code.
+ *
+ * For example, for such code:
+ * ```
+ * use TypeLang\Parser\Node;
+ * use TypeLang\Parser\Exception as Error;
+ * ```
+ *
+ * You need to create a rule like this:
+ * ```
+ * $transformer = new PhpUseStatementsTransformer([
+ *     'TypeLang\Parser\Node',                     // for `use TypeLang\Parser\Node;`
+ *     'Error' => 'TypeLang\Parser\Exception',     // for `use TypeLang\Parser\Exception as Error;`
+ * ]);
+ * ```
+ *
+ * Then, if you apply it to the finished result, you will get
+ * normalized substitutions:
+ * ```
+ * $sourceAst = new TypeLang\Parser\Parser()
+ *     ->parse(<<<'PHP'
+ *         array { Node, Error\SemanticException }
+ *         PHP);
+ *
+ * $transformedAst = new \TypeLang\Parser\TypeResolver()
+ *     ->resolve($sourceAst, $transformer);
+ *
+ * // Expected Output:
+ * // > array{
+ * // >     TypeLang\Parser\Node,
+ * // >     TypeLang\Parser\Exception\SemanticException
+ * // > }
+ * ```
+ */
+final readonly class PhpUseStatementsTransformer implements TransformerInterface
+{
+    /**
+     * @var array<non-empty-lowercase-string, Name>
+     */
+    private array $replacements;
+
+    /**
+     * @param iterable<non-empty-string|array-key, non-empty-string|Name> $replacements
+     */
+    public function __construct(iterable $replacements)
+    {
+        $this->replacements = $this->format($replacements);
+    }
+
+    /**
+     * @param iterable<array-key, non-empty-string|Name> $replacements
+     * @return array<non-empty-lowercase-string, Name>
+     */
+    private function format(iterable $replacements): array
+    {
+        $result = [];
+
+        foreach ($replacements as $key => $replacement) {
+            // normalize value
+            if (\is_string($replacement)) {
+                $replacement = Name::createFromString($replacement);
+            }
+
+            // normalize key
+            if (\is_int($key) || $key === '') {
+                $key = $replacement->last->toString();
+            }
+
+            $result[\strtolower($key)] = $replacement;
+        }
+
+        return $result;
+    }
+
+    public function __invoke(Name $name): ?Name
+    {
+        $first = \strtolower($name->first->toString());
+        $prefix = $this->replacements[$first] ?? null;
+
+        return $prefix?->mergeWith($name);
+    }
+}

libs/parser/src/TypeResolver/TransformerInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Parser\TypeResolver;
+
+use TypeLang\Node\Name;
+
+interface TransformerInterface
+{
+    public function __invoke(Name $name): ?Name;
+}