Does PHPStan has an equivalent to TypeScript's unknown?

[BastienClement]

Hi there,

As I currently understand it, PHPStan allows us to select one of two behavior for mixed

• either non-strict (level < 9) in which case it is basically left unchecked and every usage of it is valid,
• or strict (level = 9), in which case it is basically a type with no use case except for narrowing it to something useful (eg. with is_bool)

If I'm not mistaken, the first case matches the any behavior from TypeScript, while the second matches unknown.

In our specific use case, we are not able to enable level 9 globally on our project since a lot of legacy code is written around mixed and fully typing it is an unachievable goal. However in some places, we actually do have an unknown value coming from some database or external service and would like to ensure that every usage of it is correctly guarded by type-checking code at runtime.

In this case, TypeScript let developers select the top-type behavior in a case by case basis, while it seems that PHPStan forces a single behavior tied to a global config toggle.

Is there a way to achieve a similar strict-top-type in PHPStan, or would something similar be achievable with a reasonable effort by somehow enabling the strict mixed behavior on a case by case basis ?

[staabm]

Just a answer on this particular thing:

unknown value coming from some database

You might use https://github.com/staabm/phpstan-dba in case you are using mysqli or pdo_mysql as a db connector (pdo_pgsql will be supported soon) to make phpstan aware of the database types

[BastienClement]

This was intended as a simple example use case.

My actual use case is for a custom DynamicReturnTypeExtension that is not yet able to handle every single possible cases and for which I would like to return something that correctly conveys the "I don't know what this is" info. The intent is for the developer to annotate the correct type at the call site in these rare scenario while still being able to use the vast majorities of correctly inferred ones in the meantime.

Using mixed in this case at level <9 would let the usage go unchecked in this particular scenario.

[ondrejmirtes]

You might have some luck by returning StrictMixedType from dynamic return type extensions.

This is how level 9 works - it transforms explicit MixedType into StrictMixedType.

[mnapoli]

I am in this exact situation: I want to type the response of an API call as "unknown", so that all the code downstream has to carefully narrow the types.

Is this achievable without a type extension?

As mentioned in the original question, in TS it is common to use "unknown" to force the caller to deal with type narrowing. Something of the sort with PHPStan (regardless of the level) would be awesome.

[stof]

The solution without type extension is to use mixed as type and to use the level 9 of phpstan.

[mad-briller]

It would also be relatively simple to implement your own TypeNodeResolverExtension which interprets @return unknown to be a StrictMixedType:

https://phpstan.org/developing-extensions/custom-phpdoc-types

[mnapoli]

The solution without type extension is to use mixed as type and to use the level 9 of phpstan.

we are not able to enable level 9 globally on our project

That was the premise.

Thanks @mad-briller