Mixin static return behaving like self

[markhuot]

Hello, given the following I would have expected the return type to be ChildClass but PHPStan is reporting ParentClass. I would have expected the @mixin to work like a trait and return the calling, ChildClass via late static binding.

https://phpstan.org/r/05a30038-b162-4441-9d69-11d7cc7c0d5f

<?php

/**
 * @method static parentMethod()
 */
class ParentClass {}

/**
 * @mixin ParentClass
 */
class Child {}

\PHPStan\testing\assertType(Child::class, (new Child)->parentMethod());

Using native traits the static return is resolved as I would have expected with late static binding and PHPStan correctly sees the ChildClass return from ->parentMethod().

https://phpstan.org/r/31f0907e-5a54-4c79-a375-e405fc0ca532

<?php

/**
 * @method static parentMethod()
 */
trait ParentClass {
}

class ChildClass {
    use ParentClass;
}

\PHPStan\testing\assertType(ChildClass::class, (new ChildClass)->parentMethod());

The question is whether @mixin should support late static binding and resolve a static return to the calling class and not the defined class.

---

Note: a workaround is to make ParentClass generic and specifically pass through the returning class.

https://phpstan.org/r/894ecbec-6d97-441b-8aa4-a067ddc3789c

<?php

/**
 * @template T
 * @method T parentMethod()
 */
class ParentClass {
}

/**
 * @mixin ParentClass<ChildClass>
 */
class ChildClass {
}

\PHPStan\testing\assertType(ChildClass::class, (new ChildClass)->parentMethod());

[ondrejmirtes]

Can you share the actual code that makes this work? To me it seems kind of weird - how could be the ParentClass aware of where the method is called from, in order to return Child?

[markhuot]

It's coming out of https://github.com/craftcms/cms. Specifically Craft creates a CustomFieldDefinition at runtime that contains the field schema stored in the database. That file looks something like this. The @method docblocks are dynamic and change whenever you modify your schema.

/**
 * @method static sampleTextField(mixed $value) Sets the [[sampleTextField]] property
 * @method static anotherField(mixed $value) Sets the [[anotherField]] property
 */
class CustomFieldBehavior extends Behavior
{
    public $values = [];

    public function __call($name, $params)
    {
        // stores any values passed in to the methods
        // for later retrieval. basically,
        $this->values[$name] = $params;
    }
}

A query builder then proxies calls to custom fields and sends them off to the CustomFieldBehavior. The CustomFieldBehaivor is responsible for holding all the data you're searching against. Then, when the query executes, the values are transformed in to SQL and sent to the database.

/**
 * @mixin CustomFieldBehavior
 */
class EntryQuery {
    // the behavior is added on initialization
    public function __construct() {
        $this->customFields = new CustomFieldBehavior;
    }

    // calls to custom fields are proxied to the CustomFieldBehavior
    public function __call($name, $params) {
        $this->customFields->$name(...$params);

        return $this;
    }

    // when queried the EntryQuery grabs the values from CustomFieldBehavior
    // and turns them in to WHERE statements against the database
    public function all() {
        $sql = $this->createSqlFor($this->customFields->values);

        return $this->execute($sql);
    }
}

Few things of note,

In EntryQuery the __call magic method returns $this (which is the EntryQuery). This is intentional so that you can chain multiple fields on to a query. For example you can do this,

(new EntryQuery)->sampleTextField('foo')->anotherField('bar')->all();

That should,

1. create a new EntryQuery
2. set the CustomFieldBehavior::$value['sampleTextxField'] = 'foo' for later querying
3. set the CustomFieldBehavior::$value['anotherField'] = 'bar' for later querying
4. return the same EntryQuery from step 1 after step 2 and 3
5. query the database when ->all() is called using the data from steps 2 and 3

Right now (new EntryQuery)->sampleTextField('foo') returns a type of CustomFieldDefinition when I would like it to return the EntryQuery it's called on.

I think I may see where some of the confusion stems from. The EntryQuery::__call is not returning the result of CustomFieldDefinition. It's returning itself (the EntryQuery) irregardless of what CustomFieldDefinition does. We're using the @mixin for the method names, but the return of those methods is discarded.

I don't know if that helps or confuses things. I have a small reproducible repo here, https://github.com/markhuot/craft-phpstan/blob/722498d40729ac69c284a2f536aae5c2e1fb268f/modules/Module.php#L25. That shows the "Dumped type" on line 25 is the CustomFieldBehavior when I would have expected it to be the EntryQuery. https://github.com/markhuot/craft-phpstan/actions/runs/7824261446