Interpret type from already defined @template Generic which is itself a Generic

[alexander-schranz]

I'm asking if something like this is maybe already possible. I have a generic like this:

/**
 * @implements ModelInterface<Child>
 */
class Model implements ModelInterface
{
}

/**
 * @template T of ChildInterface
 */
interface ModelInterface {
}

/**
 * @implements ChildInterface<Model>
 */
class Child implements ChildInterface
{
}

/**
 * @template T of ModelInterface
 */
interface ChildInterface {
}

And a service which is something like this Service<Model>. It has a method which returns ChildInterface which I want automatically detect the return based on the given Model generic. Currently I need to define also the Child as generic template which I want to avoid as the Model is responsibility what to the correct Child class and not the Service should require to define also that generic.

The full example can be found here as I think else its very confusing:

https://phpstan.org/r/d4c0e34b-096b-41c2-ab96-a143980a0765

I'm not sure if something like this picking a type based on the defined generic already possible. First read about Pick but thats I think not implemented in core and only works with properties not get the generic value. I even thought I could go over phpstan-type definition but that is not interpreted like I thought.

[ondrejmirtes]

I looked at your example and implemented the one missing piece - a way to extract template type from an existing type, an equivalent to calling Type::getTemplateType(): https://apiref.phpstan.org/1.10.x/PHPStan.Type.Type.html#_getTemplateType

So working code now looks like this:

/**
 * @template-covariant T of ModelInterface
 */
class Helper
{
	/**
	 * @param T $model
	 */
	public function __construct(private ModelInterface $model)
	{}

	/**
	 * @return template-type<T, ModelInterface, 'TChild'>
	 */
	public function getFirstChildren(): ChildInterface
	{
		$firstChildren = $this->model->getChildren()[0] ?? null;

		if (!$firstChildren) {
			throw new \RuntimeException('No first child found.');
		}

		return $firstChildren;
	}
}

Updated playground: https://phpstan.org/r/d734d19d-f9d1-4cc3-813f-65ef69d04454

Code: phpstan/phpstan-src@b6d0c87

[JanTvrdik]

This is how it would look like in TypeScript.

public getFirstChildren(): T extends ModelInterface<infer TChild> ? TChild : never
{}

And if used multiple times, it would be extracted to helper type

type ExtractChild<T extends ModelInterface> = T extends ModelInterface<infer TChild> ? TChild : never

public getFirstChildren(): ExtractChild<T> {
  throw new Error()
}

[JanTvrdik]

And in AFAIK in more traditional languages like Java, this is not possible at all. You must always explicitly specify the TChild type, so there is nothing to infer. The Helper class would look sth like

class Helper<TChild is ChildInferface, TModel is ModelInterface<TChild>> {
  fun getFirstChild(): TChild
}

[ondrejmirtes]

Two @template above Helper aren't great (feels like a workaround) and for the conditional type about T extends ModelInterface<infer TChild> ? TChild : never we'd have to implement quite a few more things to work.

So I think template-type<...> is the way to go. We already have several "helper PHPDoc types" that are about calling methods on Type interface so it's fine to add another :)

[alexander-schranz]

Another usecase where the generic is not on the class instead of the class-method also works like expected: https://phpstan.org/r/3f3b4f85-4a5a-4259-84e0-5e675227325d. 👍

[ondrejmirtes]

Yeah, that works and it's okay to use it like that, but this use-case was already achievable before: https://phpstan.org/r/e58a4e99-ab05-4f71-9c3e-13119ec73f2f