PHPDoc et fin (statique ou dynamique) de liaison

Question

La plupart PHP IDEs comptent sur phpdoc pour obtenir des conseils sur le type d'une expression. Et pourtant, je l'utilise souvent ce modèle, qui ne semble pas être couvert:

class Control {
    private $label = '';

    /** @return ??? */
    public static function Make(){ return new static(); }

    /** @return ??? */
    public function WithLabel($value){  $this->label = $value;  return $this;  }

    /** @return void */
    public function Render(){ /* ... */ }
}

class Textbox extends Control {
   private $text = '';

    /** @return ??? */
    public function WithText($text){  $this->width = $text;  return $this;  }
}

Maintenant, je peux utiliser les classes comme ceci:

Textbox::Make()           // <-- late static binding, returns Textbox
   ->WithLabel('foo')     // <-- late dynamic binding, returns Textbox
   ->WithText('bar')      // <-- normal binding, returns Textbox
   ->Render();

Est-il possible de remplacer le « ??? » s avec quelque chose afin que les informations de frappe est correcte?

Answer 1

/** @return Control */

en cas de non-statique:

/** @return $this */

mais il est pas documenté dans le manuel phpdoc

Answer 2

réponse Mise à jour en prenant comme référence les plus populaires PHP IDE (PHPStorm 8):

Pour @return vous pouvez utiliser:

• self
• $this

Pour @method vous pouvez utiliser:

• $this

Exemple:

/**
 * Class Model
 * @method $this parentMethodA
 */
class Model
{
    /**
     * @return $this
     */
    public function parentMethodB()
    {
        return $this;
    }

    /**
     * @return self
     */
    public function parentMethodC()
    {
        return $this;
    }
}


/**
 * Class Person
 * @method $this childMethodA
 */
class Person extends Model
{
    /**
     * @return $this
     */
    public function childMethodB()
    {
        return $this;
    }

    /**
     * @return self
     */
    public function childMethodC()
    {
        return $this;
    }
}

$p = new Person();

//In the following lines IDE will recognize those variables as:
$t1 = $p->parentMethodA(); //Instance of Person
$t2 = $p->parentMethodB(); //Instance of Person
$t3 = $p->parentMethodC(); //Instance of Model
$t4 = $p->parentMethodA(); //Instance of Person
$t5 = $p->parentMethodB(); //Instance of Person
$t6 = $p->parentMethodC(); //Instance of Person

Mise à jour pour PHPStorm 10 (EAP)

Il semble que maintenant static peut être utilisé aussi, mais seulement pour @return.

Answer 3

La réponse de mises à jour pour inclure les options cvsguimaraes statiques:

/**
 * Class Bar
 * @method $this parentMethodA
 */
class Bar
{
    /**
     * @return $this
     */
    public function parentMethodB()
    {
        return $this;
    }

    /**
     * @return self
     */
    public function parentMethodC()
    {
        return $this;
    }

    /**
     * @return static
     */
    public static function staticMethod()
    {
        return new static();
    }

    /**
     * @param $id
     *
     * @return bool
     */
    public function load($id)
    {
        // test
        return $id ? true : false;
    }

    /**
     * @param null $id
     *
     * @return static
     */
    public static function get($id = NULL){
        $obj = static::staticMethod();

        if (is_null($id)) {
            return $obj;
        }

        if ($obj->load($id)) {
            return $obj;
        }

        return false;
    }
}


/**
 * Class Foo
 * @method $this childMethodA
 */
class Foo extends Bar
{
    /**
     * @return $this
     */
    public function childMethodB()
    {
        return $this;
    }

    /**
     * @return self
     */
    public function childMethodC()
    {
        return $this;
    }
}

/**
 * Class Bar
 */
class Baz extends Bar 
{

}

$p = new Foo();

/** @var Foo $Foo */
$Foo = 'Foo';
$Baz = 'Bar';

//  IntelliJ recognizes the following as:
$t1 = $p->parentMethodA(); //Instance of Foo
$t2 = $p->parentMethodB(); //Instance of Foo
$t3 = $p->parentMethodC(); //Instance of Model
$t4 = $p->childMethodA(); //Instance of Foo
$t5 = $p->childMethodB(); //Instance of Foo
$t6 = $p->childMethodC(); //Instance of Foo
$t7 = $Foo::staticMethod(); //Instance of Foo
$t8 = Foo::staticMethod(); //Instance of Foo
$t9 = $p::staticMethod(); //Instance of Foo
$t10 = $Foo::get(); //Instance of Foo
$t12 = Bar::get(); //Instance of Bar
$t11 = $Baz::get(); // Unknown