<form method="POST">
    <h3>Editing: NameResolver.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);

namespace PhpParser\NodeVisitor;

use PhpParser\ErrorHandler;
use PhpParser\NameContext;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\Node\Name;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Stmt;
use PhpParser\NodeVisitorAbstract;

class NameResolver extends NodeVisitorAbstract {
    /** @var NameContext Naming context */
    protected NameContext $nameContext;

    /** @var bool Whether to preserve original names */
    protected bool $preserveOriginalNames;

    /** @var bool Whether to replace resolved nodes in place, or to add resolvedNode attributes */
    protected bool $replaceNodes;

    /**
     * Constructs a name resolution visitor.
     *
     * Options:
     *  * preserveOriginalNames (default false): An &quot;originalName&quot; attribute will be added to
     *    all name nodes that underwent resolution.
     *  * replaceNodes (default true): Resolved names are replaced in-place. Otherwise, a
     *    resolvedName attribute is added. (Names that cannot be statically resolved receive a
     *    namespacedName attribute, as usual.)
     *
     * @param ErrorHandler|null $errorHandler Error handler
     * @param array{preserveOriginalNames?: bool, replaceNodes?: bool} $options Options
     */
    public function __construct(?ErrorHandler $errorHandler = null, array $options = []) {
        $this-&gt;nameContext = new NameContext($errorHandler ?? new ErrorHandler\Throwing());
        $this-&gt;preserveOriginalNames = $options['preserveOriginalNames'] ?? false;
        $this-&gt;replaceNodes = $options['replaceNodes'] ?? true;
    }

    /**
     * Get name resolution context.
     */
    public function getNameContext(): NameContext {
        return $this-&gt;nameContext;
    }

    public function beforeTraverse(array $nodes): ?array {
        $this-&gt;nameContext-&gt;startNamespace();
        return null;
    }

    public function enterNode(Node $node) {
        if ($node instanceof Stmt\Namespace_) {
            $this-&gt;nameContext-&gt;startNamespace($node-&gt;name);
        } elseif ($node instanceof Stmt\Use_) {
            foreach ($node-&gt;uses as $use) {
                $this-&gt;addAlias($use, $node-&gt;type, null);
            }
        } elseif ($node instanceof Stmt\GroupUse) {
            foreach ($node-&gt;uses as $use) {
                $this-&gt;addAlias($use, $node-&gt;type, $node-&gt;prefix);
            }
        } elseif ($node instanceof Stmt\Class_) {
            if (null !== $node-&gt;extends) {
                $node-&gt;extends = $this-&gt;resolveClassName($node-&gt;extends);
            }

            foreach ($node-&gt;implements as &amp;$interface) {
                $interface = $this-&gt;resolveClassName($interface);
            }

            $this-&gt;resolveAttrGroups($node);
            if (null !== $node-&gt;name) {
                $this-&gt;addNamespacedName($node);
            } else {
                $node-&gt;namespacedName = null;
            }
        } elseif ($node instanceof Stmt\Interface_) {
            foreach ($node-&gt;extends as &amp;$interface) {
                $interface = $this-&gt;resolveClassName($interface);
            }

            $this-&gt;resolveAttrGroups($node);
            $this-&gt;addNamespacedName($node);
        } elseif ($node instanceof Stmt\Enum_) {
            foreach ($node-&gt;implements as &amp;$interface) {
                $interface = $this-&gt;resolveClassName($interface);
            }

            $this-&gt;resolveAttrGroups($node);
            $this-&gt;addNamespacedName($node);
        } elseif ($node instanceof Stmt\Trait_) {
            $this-&gt;resolveAttrGroups($node);
            $this-&gt;addNamespacedName($node);
        } elseif ($node instanceof Stmt\Function_) {
            $this-&gt;resolveSignature($node);
            $this-&gt;resolveAttrGroups($node);
            $this-&gt;addNamespacedName($node);
        } elseif ($node instanceof Stmt\ClassMethod
                  || $node instanceof Expr\Closure
                  || $node instanceof Expr\ArrowFunction
        ) {
            $this-&gt;resolveSignature($node);
            $this-&gt;resolveAttrGroups($node);
        } elseif ($node instanceof Stmt\Property) {
            if (null !== $node-&gt;type) {
                $node-&gt;type = $this-&gt;resolveType($node-&gt;type);
            }
            $this-&gt;resolveAttrGroups($node);
        } elseif ($node instanceof Stmt\Const_) {
            foreach ($node-&gt;consts as $const) {
                $this-&gt;addNamespacedName($const);
            }
        } elseif ($node instanceof Stmt\ClassConst) {
            if (null !== $node-&gt;type) {
                $node-&gt;type = $this-&gt;resolveType($node-&gt;type);
            }
            $this-&gt;resolveAttrGroups($node);
        } elseif ($node instanceof Stmt\EnumCase) {
            $this-&gt;resolveAttrGroups($node);
        } elseif ($node instanceof Expr\StaticCall
                  || $node instanceof Expr\StaticPropertyFetch
                  || $node instanceof Expr\ClassConstFetch
                  || $node instanceof Expr\New_
                  || $node instanceof Expr\Instanceof_
        ) {
            if ($node-&gt;class instanceof Name) {
                $node-&gt;class = $this-&gt;resolveClassName($node-&gt;class);
            }
        } elseif ($node instanceof Stmt\Catch_) {
            foreach ($node-&gt;types as &amp;$type) {
                $type = $this-&gt;resolveClassName($type);
            }
        } elseif ($node instanceof Expr\FuncCall) {
            if ($node-&gt;name instanceof Name) {
                $node-&gt;name = $this-&gt;resolveName($node-&gt;name, Stmt\Use_::TYPE_FUNCTION);
            }
        } elseif ($node instanceof Expr\ConstFetch) {
            $node-&gt;name = $this-&gt;resolveName($node-&gt;name, Stmt\Use_::TYPE_CONSTANT);
        } elseif ($node instanceof Stmt\TraitUse) {
            foreach ($node-&gt;traits as &amp;$trait) {
                $trait = $this-&gt;resolveClassName($trait);
            }

            foreach ($node-&gt;adaptations as $adaptation) {
                if (null !== $adaptation-&gt;trait) {
                    $adaptation-&gt;trait = $this-&gt;resolveClassName($adaptation-&gt;trait);
                }

                if ($adaptation instanceof Stmt\TraitUseAdaptation\Precedence) {
                    foreach ($adaptation-&gt;insteadof as &amp;$insteadof) {
                        $insteadof = $this-&gt;resolveClassName($insteadof);
                    }
                }
            }
        }

        return null;
    }

    /** @param Stmt\Use_::TYPE_* $type */
    private function addAlias(Node\UseItem $use, int $type, ?Name $prefix = null): void {
        // Add prefix for group uses
        $name = $prefix ? Name::concat($prefix, $use-&gt;name) : $use-&gt;name;
        // Type is determined either by individual element or whole use declaration
        $type |= $use-&gt;type;

        $this-&gt;nameContext-&gt;addAlias(
            $name, (string) $use-&gt;getAlias(), $type, $use-&gt;getAttributes()
        );
    }

    /** @param Stmt\Function_|Stmt\ClassMethod|Expr\Closure|Expr\ArrowFunction $node */
    private function resolveSignature($node): void {
        foreach ($node-&gt;params as $param) {
            $param-&gt;type = $this-&gt;resolveType($param-&gt;type);
            $this-&gt;resolveAttrGroups($param);
        }
        $node-&gt;returnType = $this-&gt;resolveType($node-&gt;returnType);
    }

    /**
     * @template T of Node\Identifier|Name|Node\ComplexType|null
     * @param T $node
     * @return T
     */
    private function resolveType(?Node $node): ?Node {
        if ($node instanceof Name) {
            return $this-&gt;resolveClassName($node);
        }
        if ($node instanceof Node\NullableType) {
            $node-&gt;type = $this-&gt;resolveType($node-&gt;type);
            return $node;
        }
        if ($node instanceof Node\UnionType || $node instanceof Node\IntersectionType) {
            foreach ($node-&gt;types as &amp;$type) {
                $type = $this-&gt;resolveType($type);
            }
            return $node;
        }
        return $node;
    }

    /**
     * Resolve name, according to name resolver options.
     *
     * @param Name $name Function or constant name to resolve
     * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
     *
     * @return Name Resolved name, or original name with attribute
     */
    protected function resolveName(Name $name, int $type): Name {
        if (!$this-&gt;replaceNodes) {
            $resolvedName = $this-&gt;nameContext-&gt;getResolvedName($name, $type);
            if (null !== $resolvedName) {
                $name-&gt;setAttribute('resolvedName', $resolvedName);
            } else {
                $name-&gt;setAttribute('namespacedName', FullyQualified::concat(
                    $this-&gt;nameContext-&gt;getNamespace(), $name, $name-&gt;getAttributes()));
            }
            return $name;
        }

        if ($this-&gt;preserveOriginalNames) {
            // Save the original name
            $originalName = $name;
            $name = clone $originalName;
            $name-&gt;setAttribute('originalName', $originalName);
        }

        $resolvedName = $this-&gt;nameContext-&gt;getResolvedName($name, $type);
        if (null !== $resolvedName) {
            return $resolvedName;
        }

        // unqualified names inside a namespace cannot be resolved at compile-time
        // add the namespaced version of the name as an attribute
        $name-&gt;setAttribute('namespacedName', FullyQualified::concat(
            $this-&gt;nameContext-&gt;getNamespace(), $name, $name-&gt;getAttributes()));
        return $name;
    }

    protected function resolveClassName(Name $name): Name {
        return $this-&gt;resolveName($name, Stmt\Use_::TYPE_NORMAL);
    }

    protected function addNamespacedName(Node $node): void {
        $node-&gt;namespacedName = Name::concat(
            $this-&gt;nameContext-&gt;getNamespace(), (string) $node-&gt;name);
    }

    protected function resolveAttrGroups(Node $node): void {
        foreach ($node-&gt;attrGroups as $attrGroup) {
            foreach ($attrGroup-&gt;attrs as $attr) {
                $attr-&gt;name = $this-&gt;resolveClassName($attr-&gt;name);
            }
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>