PHPStan as a library: resolve namespaces

[rodion-k]

I'm trying to use PHPStan as a library and get an anonymous function return type. And it seems there is some problem with namespace resolving.

The example below outputs *ERROR* if the Test class doesn't have FQN and outputs int (as expected) if it is. Both function.php and Test.php files are located in the src/Projection directory.

function.php:

namespace App\Projection;

//It will work if FQN is specified: \App\Projection\Test()
return fn() => (new Test())->a;

Test.php:

namespace App\Projection;

class Test
{
    public int $a = 1;
}

index.php:

use PHPStan\Analyser;

require __DIR__ . '/vendor/autoload.php';

$container = (new \PHPStan\DependencyInjection\ContainerFactory(__DIR__))->create(
    tempDirectory: sys_get_temp_dir(),
    additionalConfigFiles: [],
    analysedPaths: [__DIR__ . '/src'],
    composerAutoloaderProjectPaths: [__DIR__ . '/vendor/autoload.php'],
);
$internalScopeFactory = new Analyser\LazyInternalScopeFactory(Analyser\MutatingScope::class, $container);
$scopeFactory = new Analyser\ScopeFactory($internalScopeFactory);
$reflectionProvider = $container->getByType(\PHPStan\Reflection\ReflectionProvider::class);
$phpParser = (new \PhpParser\ParserFactory)->create(\PhpParser\ParserFactory::PREFER_PHP7);

$file = __DIR__ . '/src/Projection/function.php';
$ast = $phpParser->parse(file_get_contents($file));
$node = $ast[0]->stmts[0]->expr;

$scope = $scopeFactory->create(Analyser\ScopeContext::create($file));
$returnType = $scope->enterArrowFunction($node)->getAnonymousFunctionReturnType();

echo $returnType->describe(\PHPStan\Type\VerbosityLevel::precise()), PHP_EOL;

Thanks

[ondrejmirtes]

Hello, what you're trying to use PHPStan for? Please give me as much details as possible and I'll try to point you in the right direction.

[rodion-k]

Hi Ondrej, the idea is to use PHPStan to create the OpenApi specification. There is a lot of code like this in our project:

return [
    'a' => function() {...},
    'b' => function() {...},
];

It maps our internal data structures to the API response.
So my goal is to resolve types using PHPStan and then convert them to OpenApi types.

[ondrejmirtes]

Can you be more specific? What's the output you're targetting? Do you want to create JSON from some collected data about your codebase?

[rodion-k]

The output will be OpenApi spec. OpenApi provides a way to describe the data structure, so I want to use PHPStan to automatically generate this specification rather than manually describing it.
For example such a code:

return [
    'a' => function() {
        return time();
    },
    'b' => function() {
        return uniqid();
    },
];

produces a JSON like this:

{
    "a": 1704824965,
    "b": "659d90922fbe2"
}

So I want to extract type information from the code to create an OpenApi specification that will describe an object with property a of type int and property b of type string. This example already works for me, but as I described above, it does not work in an anonymous function containing classes.

[ondrejmirtes]

Perfect, that's what I wanted to know. I believe there's a much nicer way to solve this task.

PHPStan uses PHPStan itself to generate identifiers reported by PHPStan rules to render this webpage: https://phpstan.org/error-identifiers

You can see the links that lead to the specific location in code where each identifier is reported!

This task is performed by this project: https://github.com/phpstan/phpstan/tree/1.11.x/identifier-extractor

The important pieces are:

• Custom rules and collectors (https://phpstan.org/developing-extensions/rules, https://phpstan.org/developing-extensions/collectors)
• Custom error formatter to produce the final JSON (https://phpstan.org/developing-extensions/error-formatters)

Check out:

• extractor.neon (https://github.com/phpstan/phpstan/blob/1.11.x/identifier-extractor/extractor.neon)
• The workflow that's used to run this project: https://github.com/phpstan/phpstan/blob/1.11.x/.github/workflows/extract-identifiers.yml

So you run PHPStan as usual with a custom config to collect the data you need. The advantage is that you don't have to replicate any of internal code, and you also get parallelism for free.

Other similar project using the same approach is https://gitlab.com/stella-maris/callmap.

[rodion-k]

Looks interesting, I will give it a try and will let you know, thanks a lot!