Définition de l'alias de la fonction Trait dans la méthode magique __callStatic

Question

J'ai un trait Queryable qui utilise la méthode __callStatic pour créer une nouvelle instance d'un Builder et exécuter la fonction appelée dessus si elle existe. Il renvoie un générateur pour enchaîner les requêtes (similaire à Eloquent).

Maintenant, j'essaie d'implémenter une interface qui nécessite une fonction find(), mais la fonction find() est déclarée dans le phpDoc du trait Queryable (@method static static find (mixed $primaryKeyValue) ), ce qui crée un conflit :

La déclaration de find(primaryKeyValue: Mixed) de Queryable doit être compatible avec StorageInterface->find(primaryKeyValue: Mixed) et les méthodes d'interface ne peuvent pas être créées.

Afin de résoudre ce conflit, j'ai essayé d'utiliser une méthode similaire aux alias de traits (utilisez Queryable { Queryable::find as queryFind; }), mais j'ai ensuite rencontré...

Erreur de compilation : un alias est défini pour appFrameworkTraitsQueryable::find, mais la méthode n'existe pas.

Je n'arrive pas à trouver de solution. Quelqu'un peut-il m'aider ? :) (Je crois que cela a à voir avec une sorte de vérification d'existence de la classe puisque c'est une méthode magique, mais je ne sais pas non plus comment y remédier..)

 premier(int $montant = 1)
 * @method static static|array dernier(int $montant = 1)
 * @method chaîne statique getQuery()
 * @method chaîne statique getRawQuery()
 * @method chaîne statique getPrimaryKey()
 * @method static static find (mixte $primaryKeyValue)
 * Tableau statique @method tous()
 * Tableau statique @method obtenir()
 * @method Paginator statique paginate()
 * @method table de constructeur statique (string $tableName)
 * @method static Builder PrimaryKey(string $primaryKey)
 * @method static Builder parPage(int $perPageAmount)
 * @method static Builder où (string $column, mixte $operatorOrValue = null, mixte $value = null)
 * @method static BuilderwhereIn(string $column, array $search)
 * @method static BuilderwhereNotNull(string $column)
 * @method static Builder select(...$colonnes)
 * @method static Builder avec (string $relation, Closure $closure)
 * @method static Builder orderBy(string $column, string $direction = 'desc')
 * Limite du constructeur statique @method (int $amount)
 * @method static Builder offset(int $montant)*/
trait Interrogable
{
    fonction statique publique __callStatic (string $name, array $arguments)
    {
        $functions = get_class_methods(Builder::class);
        if (in_array ($ nom, $ fonctions)) {
            $builder = new Builder(static::class);
            return $builder->$name(...$arguments);
        }

        $selfFunctions = get_class_methods($callClass = static::class);
        if (!in_array($name, $selfFunctions)) {
            throw new BadMethodCallException("La méthode statique '{$name}' n'existe pas sur {$callClass}.");
        }

        return static::$name(...$arguments);
    }

}


la classe BaseModel étend stdClass implémente QueryableInterface, StorableInterface
{
    utilisez interrogeable {
        Queryable :: find en tant que queryFind ;
    }

    fonction publique find (mixte $primaryKeyValue) : statique
    {
        return self::queryFind($primaryKeyValue);
    }
}

Answer 1

Les méthodes de traits peuvent être "renommées" : (en fait un alias)

use Queryable {
    find as MyFind;
}

Référence

Exemple simple :

<?php

Trait myTrait
{
    public static function __callStatic ($method, $arguments)
    {
        $className = self::class;
        
        return (new $className ())->$method(...$arguments);
    }
    
    
    private function find()
    {
        echo "\naaaaaaaaaaaaa\n";
        return $this;
    }
}


interface MyInterface
{
    public function find();
}   


class Test Implements MyInterface
{
    Use myTrait {
        find as myFind;
    }
    
    public function find()
    {
        echo "\nxxxxxx\n";
    }
    
}


Test::myFind()->find();