Indexed Access Types

[markhuot]

I'm using the action pattern with plain PHP Classes and hoping to create an invoke($className) helper to call the actions. For example here's a PHPStan link, https://phpstan.org/r/87a1c773-792a-492a-b474-00a2155951f4. The @return of my helper is pseudo code because I'm not sure it's possible to type something to a method return?

<?php declare(strict_types = 1);

class MyGreatAction {
  public function __invoke(): string {
    return 'foo';
  }
}

/**
 * @template T
 * @param class-string<T> $class
 * @return T->__invoke()
 */
function invoke(string $class) {
  return (new $class)();
}

$foo = invoke(MyGreatAction::class);

This is possible in Typescript via "indexed types" where you can specify the return is based on a method of the generic. Here the T['handle'] works its magic. https://www.typescriptlang.org/play?#code/C4TwDgpgBAwg9gOwM7AE4FcDGw6oDwAqAfFALxQIQDuUAFAHSMCGqA5kgFxRMIgDaAXQCUZEgQDcAKACWCYBFQAzJpmgBBbNMRMARgBtoAb0lRTUABY8AJgdpCuPEJIC+kyZj1MkSKAFkQAOKoEEzAGsBaCFDGppYINhB2XCiosqzRJmbBwOioUQDkinBw+VKmrq6SiugImohQsgBucADWEIRQEAAe8vE+4ZG6BkS0MJ7eAHJMALYQXPDIaFg4+MT2UAR8+XEJ+QIZZlDZuVGUNGNeSFOzdvQ7tkJSlZiIKFApaQBqTHro0ORNVqJfxBEJhOoIR5AA

type Constructor<T> = new (...args: any[]) => T;
interface Actionable {
    handle(): any
}

class MyGreatAction {
  handle(): string {
    return 'foo';
  }
}

function invoke<T extends Actionable>(ClassName: Constructor<T>): T['handle'] {
    return new ClassName().handle();
}

const stringValue = invoke(MyGreatAction);

Is something like this possible in PHPStan?

[ondrejmirtes]

This currently isn't possible. TypeScript can afford that because in JS foo['bar'] allows to access members like properties and methods, but in PHP that means array offset access or ArrayAccess interface.

But this is close to a feature I'd like to do one day: https://twitter.com/OndrejMirtes/status/1606017239882338304

Meanwhile you can implement this yourself using a TypeNodeResolverExtension: https://phpstan.org/writing-php-code/phpdoc-types

So it could look like @return callable-return<T>.

The Type implementation will be very close to this one: https://github.com/phpstan/phpstan-src/blob/1.11.x/src/Type/Helper/GetTemplateTypeType.php (the context: #9053)

Except the getResult method will not call $this->type->getTemplateType, but instead will do something like this:

$variant = ParametersAcceptorSelector::selectSingle($this->type->getCallableParametersAcceptors(new OutOfClassScope()));

return $variant->getReturnType();

Feel free to ask more questions if you decide to implement it!

[markhuot]

I'm working on implementing this now and have the TypeNodeResolverExtension set up and it has a resolve method that is correctly finding @return callable-return<T> in my docblocks. If I return a new \PHPStan\Type\StringType() type from resolve it I correctly see \PHPStan\dumpType(invoke(Foo::class)) dumps string type.

So, the next step is to implement the logic to reach in to the generic and pull out the callable return.

I think that is your next comment but I'm not sure about: "The Type implementation will be very close to this one: https://github.com/phpstan/phpstan-src/blob/1.11.x/src/Type/Helper/GetTemplateTypeType.php (the context: #9053)". Will I also need to implement my own type/helper for the extension to resolve/return? Or can I pull the type out of the generic in the resolve method of the extension?

Something like this… https://github.com/markhuot/callable-return/blob/518933da0fa1cb17a27f5a0da9ef5ac819017a6e/CallableReturn.php#L25

I've made some progress and updated the comment. I now have the generic type, but the return is now mixed not the :string from my __invoke method.

$type = $this->typeNodeResolver->resolve($typeNode->genericTypes[0], $nameScope);
$variant = ParametersAcceptorSelector::selectSingle($type->getCallableParametersAcceptors(new OutOfClassScope()));
return $variant->getReturnType();

https://github.com/markhuot/callable-return/blob/4399c94c8a266b1a0195f228f035573108ff916c/CallableReturn.php#L36-L38

[ondrejmirtes]

You can't do this in TypeNodeResolverExtension precisely because it needs to be late-resolvable. So you need to create a new Type implementation, something like CallableReturnType and resolve it there in a lazy fashion.

Why - see for example this commit, what it did and what bug it fixed :) phpstan/phpstan-src@234f77d It's gonna be much clearer.