How to find the fully qualified class name from 'self' => StaticCall node type

[clementbirkle]

Hello,

I've come across this fascinating project and I'm currently in the process of crafting my inaugural custom rule. However, I've encountered a challenge when attempting to obtain the fully qualified class name.

I have a class like that:

<?php

class Demo {
    public static function methodName()
    {
        self::anotherMethod();
    }
}

?>

I'm interested in applying a certain operation to self::anotherMethod();.

Here is my custom rule:

<?php

declare(strict_types=1);

namespace Utils\Rector\Rector;

use PhpParser\Node;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Stmt\Class_;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
use Rector\Core\Rector\AbstractRector;
use ReflectionException;
use ReflectionMethod;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ConvertStaticMethodCallsRector extends AbstractRector
{
    /**
     * @return array<class-string<Node>>
     */
    public function getNodeTypes(): array
    {
        return [StaticCall::class];
    }

    /**
     * @param StaticCall $node
     */
    public function refactor(Node $node): ?Node
    {
        $className = $node->class->toString();
        echo $className;

        $className = $this->getName($node->class);
        echo $className;

        return null;
    }
}

In my example, I expected to retrieve Demo for my class name but instead I got self.
The 2 echo in my example return self.

Are you familiar with a potential solution to acquire the fully qualified class name in this particular scenario?

[clementbirkle]

I found a solution for this case like that:

    /**
     * @param StaticCall $node
     */
    public function refactor(Node $node): ?Node
    {
        $className = $this->getName($node->class);
        $originalClassName = $className;

        if ($className === 'self') {
            $className = $this->getFullyQualifiedClassName($this->file);

            if (!$className) {
                return null;
            }
        }
    }

    protected function getFullyQualifiedClassName(File $file): ?string
    {
        $fileContent = $file->getFileContent();

        $parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);

        try {
            $parsedNodes = $parser->parse($fileContent);

            if (!is_array($parsedNodes)) {
                return null; // Unable to parse the file
            }

            $nodeFinder = new NodeFinder();
            $classNode = $nodeFinder->findFirst($parsedNodes, function ($node) {
                return $node instanceof \PhpParser\Node\Stmt\Class_;
            });

            if ($classNode && $classNode->name) {
                $namespace = '';
                foreach ($parsedNodes as $parsedNode) {
                    if ($parsedNode instanceof \PhpParser\Node\Stmt\Namespace_) {
                        $namespace = $parsedNode->name->toString();
                        break;
                    }
                }
                $className = $namespace . '\\' . $classNode->name->name;

                return $className;
            } else {
                return null;
            }
        } catch (Error $error) {
            return null;
        }
    }

But I still have a problem in this case:

$nameSpace = 'App\Models\User';
$nameSpace::method();

In this case, $className = $this->getName($node->class); will give nameSpace for the class name and not App\Models\User.