Type hinting challenges with callable arguments

[winterwald]

I'm experimenting with the callable function types in PHPStan and I'm getting a warning I'm not sure how to address.
My code example you could find here: https://phpstan.org/r/4c21a771-5f58-4cfb-a4b6-67515fc4f776

<?php

declare(strict_types=1);

namespace App;

use function random_int;

final class Cloner
{
    public function duplicate(Person $person): Person
    {
        $otherPerson = new Person();
        $this->setIfNotNulls(
            [$person->isLiving(...), $otherPerson->setIsLiving(...)],
            [$person->getName(...), $otherPerson->setName(...)],
        );

        return $otherPerson;
    }

    /**
     * @template T
     * @param array{
     *     callable():(T|null),
     *     callable(T):void
     * } ...$pairs
     */
    private function setIfNotNulls(array ...$pairs): void
    {
        foreach ($pairs as [$getter, $setter]) {
            $this->setIfNotNull($getter, $setter);
        }
    }

    /**
     * @template T
     * @param callable():(T|null) $getter
     * @param callable(T): void $setter
     */
    private function setIfNotNull(callable $getter, callable $setter): void
    {
        $value = $getter();
        if ($value !== null) {
            $setter($value);
        }
    }
}

final class Person
{
    private ?bool $isLiving;
    private ?string $name;

    public function __construct(?bool $isLiving = null, ?string $name = null)
    {
        $this->isLiving = $isLiving;
        $this->name = $name;
    }

    public function isLiving(): ?bool
    {
        return $this->isLiving;
    }

    public function setIsLiving(bool $isLiving): void
    {
        $this->isLiving = $isLiving;
    }

    public function getName(): ?string
    {
        return $this->name;
    }

    public function setName(string $name): void
    {
        $this->name = $name;
    }
}

$person = new Person(
    match (random_int(1, 3)) {
        1 => true,
        2 => false,
        3 => null,
    },
    match (random_int(1, 3)) {
        1 => 'string',
        2 => '',
        3 => null,
    }
);
$otherPerson = (new Cloner())->duplicate($person);

var_dump(
    $person,
    $otherPerson
);

The setIfNotNulls method takes a variable number of argument pairs. Each pair represents a getter and setter method from a Person object. The goal is to copy properties from one Person object to another, but only if the getter on the source object returns a non-null value.
In the setIfNotNulls method of my Cloner class, I'm getting the following warning:

Parameter #1 ...$pairs of method App\Cloner::setIfNotNulls() expects array{callable(): (bool|string|null), callable(bool|string): void}, array{Closure(): (bool|null), Closure(bool): void} given.

I alternatively tried the following approach: https://phpstan.org/r/bc5cb91e-06f9-4487-ad62-09661f3621ba

    // ...
    /**
     * @param array{
     *     callable():(bool|null),
     *     callable(bool):void
     * }|array{
     *      callable():(string|null),
     *      callable(string):void
     *  } ...$pairs
     */
    private function setIfNotNulls(array ...$pairs): void
    // ...

But then I run into the following warning:

Parameter #2 $setter of method App\Cloner::setIfNotNull() expects callable(bool|string): void, (callable(string): void)|(callable(bool): void) given.

Is there a way to document the $pairs parameter in setIfNotNulls so that the calls to the method don't raise this warning?

Thanks in advance for any help!

[lkrms]

One of the issues here is that T is resolved once per call to setIfNotNulls(), which is why it resolves to string|int to accommodate the closure pairs in the array you're passing in line 14. That's fine for the getters, which narrow string|int to string and int respectively, but the setters receive T in a contravariant position and therefore can't accept anything narrower than string|int. Unfortunately, because they only accept string and int respectively, they don't satisfy the signature requirements you've inadvertently created for them.

(To confirm this hypothesis, I've broken your code completely by replacing setter calls with getter calls, and there are no PHPStan errors: https://phpstan.org/r/85f11044-66d8-4c86-83bc-e4a4186f25de)

Your second example suffers from the same problem only because PHPStan resolves the union type to one callable with string|int parameter and return types -- which it shouldn't do IMO, but is possibly tied to some variadic parameter peculiarities.

I would refactor the code to call setIfNotNull() once per property, i.e. pass it one getter/setter pair per invocation. That way the @template T will achieve what you intend.

[VincentLanglet]

I agree with the refactoring.
You cannot expect PHPStan to not merge the T template for your variadic parameters.

It could work this way https://phpstan.org/r/cad752d6-d0e9-41ca-9b47-31c0ad319a1d

[winterwald]

Thanks, @lkrms and @VincentLanglet! I appreciate the explanations on template types. While the variadic approach was interesting, refactoring seems like the best solution here. 👍