Generics via properties instead of parameters

[spud]

I read through the "Generics in PHP using PHPDocs" article, and I'm wondering if there's a way to implement generics with a slightly different paradigm. You cite an example:

/**
 * @template T
 * @param class-string<T> $className
 * @param int $id
 * @return T|null
 */
function findEntity(string $className, int $id)

and that's a decent analog to what I'm doing in my code, but I'm using a class to build database queries, and rather than passing in the $className, I'm setting a property on my query object. So the equivalent code in my software would look like (this is an oversimplification):

class Queryer {
   public function set_tablename(string $tbl) {
      $this->tablename = $tbl;
   }
   public function set_object_class(string $className) {
      $this->object_class = $className;
   }
   public function findEntity(int $id) {
      $results = [get record from $this->tablename];
      $class = $this->object_class;
      $obj = new $class($results); 
      return $obj;
   }
}

This allows me to have one base class for database queries, but which can return virtually any class of object in my system, e.g.

$q = new Queryer();
$q->set_tablename('users');
$q->set_object_class(User::class);
$user = $q->findEntity(23);

Is there any way to squeeze this use case into the static analysis methodology? Right now, I've had to resort to "@return object|null;" which means that every time I call a class-specific method on that object, PHPStan yells at me.

[ondrejmirtes]

Hi, the easiest solution would be:

/** @template T of object */
class Queryer {
   /** @var class-string<T> */
   private $object_class;
   /** @param class-string<T> $className */
   public function __construct(string $className) {
      $this->object_class = $className;
   }
   public function set_tablename(string $tbl) {
      $this->tablename = $tbl;
   }

   /** @return T|null */
   public function findEntity(int $id) {
      $results = [get record from $this->tablename];
      $class = $this->object_class;
      $obj = new $class($results); 
      return $obj;
   }
}

$q = new Queryer(User::class);
$q->set_tablename('users');
$user = $q->findEntity(23); // knows it's User

Playground link: https://phpstan.org/r/67ace8a3-2ce7-4166-aaeb-95b4553b0f01

[spud]

Great! Seems to be working so far. I have a bunch of variations that I’ll need to tweak, but thanks for the starting point. spud.

…

On Feb 23, 2021, at 1:33 PM, Ondřej Mirtes ***@***.***> wrote: Hi, the easiest solution would be: /** @template T of object */ class Queryer { /** @var class-string<T> */ private $object_class; /** @param class-string<T> $className */ public function __construct(string $className) { $this->object_class = $className; } public function set_tablename(string $tbl) { $this->tablename = $tbl; } /** @param class-string<T> */ public function set_object_class(string $className) { $this->object_class = $className; } /** @return T|null */ public function findEntity(int $id) { $results = [get record from $this->tablename]; $class = $this->object_class; $obj = new $class($results); return $obj; } } $q = new Queryer(User::class); $q->set_tablename('users'); $user = $q->findEntity(23); // knows it's User Playground link: https://phpstan.org/r/67ace8a3-2ce7-4166-aaeb-95b4553b0f01 <https://phpstan.org/r/67ace8a3-2ce7-4166-aaeb-95b4553b0f01> — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#4594 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAEATJDBEQARFQJHSJ5MJULTAPYIDANCNFSM4YC7F47Q>.

[spud]

Well, I spoke too soon. Your example works great, with the object-class dependency passed into the constructor. My objects, however, use a setter to establish the object class, so it's more like

$q = new Queryer();

where the constructor internally calls

$this->set_object_class(User::class);

The idea is to have a top-level generic query class, but to be able to quickly generate content type-specific query classes, allowing me to create e.g. UserQueryer,BlogQueryer etc where the constructors handle setting the proper object types to return, as well as other properties specific to certain query types.

But I'd love also to have PHPStan be happy with it. So far not so happy. :-(

https://phpstan.org/r/295d38e4-d618-4572-98f9-06f720390ed2

[ondrejmirtes]

Hi, you should really refactor to the constructor approach. In the child class you can then call parent::__construct(User::class).

[spud]

Well, I'm certainly willing to consider refactoring, if it clarifies things for static analysis, but don't underestimate the effort! There are dozens of descendants of the original class, and this code has worked well unfactored for 20 years. Serves me right for starting a codebase in PHP4. LOL.

So I put together a quick mockup: https://phpstan.org/r/ae85247c-5db3-4cc4-962a-4524154b07a4 that clearly still needs some adjustments. I confess to barely having my head wrapped around this @template concept (and the "class-string" pseudotype), so please forgive my slow uptake!

To consider:

1. The query object does not require a class-string; some queries are intended to return simple arrays and not objects, so the class parameter should be optional. I'm not sure how that affects T/class-string stuff, but I'm assuming I can make it optionally null.
2. How do I specify/annotate/document the proper T type in the child class?

Cheers.

[ondrejmirtes]

If it was only about objects, I'd do this: https://phpstan.org/r/3872eac4-e55f-46b5-89b8-d2f33788923d

To allow multiple types, I'd do this: https://phpstan.org/r/b9f987f6-cab7-49d3-abee-e3f443d0e467