Comment informer PhpStorm sur la position de la méthode utilisée dans DependencyInjection, qu'elle "pense" qui n'existe pas?

Question

Existe-t-il une option pour informer PhpStorm que la méthode qu'elle dit n'existerait pas, dépasse sa portée et est définie ailleurs?

En mots plus simples:

Je exécution de la méthode:

Db::transactional($this)->transactionalUpdate($result);

J'ai définition de la méthode aussi:

public function transactionalUpdate(ImportantObjectButNotMuch $baconWithButter) 
    { 
     echo 'Do a lot of tricks...'; 
    } 

Malheureusement PhpStorm ne sait pas que l'exécution: ->transactionalUpdate($result); doit exécuter public function transactionalUpdate.

Existe-t-il une option pour écrire PhpDoc ou une autre balise pour l'informer que dans le cas d'une refactorisation de nom, il devrait également changer le nom de la fonction d'origine?

P.S. Ma structure de classe ressemble à ceci:

class Db 
{ 
    public static function transactional($object) 
    { 
     return TransactionalProxy::newInstance($object); //3. It returns ApiObject object 
    } 
} 

class ApiObject 
{ 
    public function update_record() 
    { 
     //1. I am starting from there 
     $result = new ImportantObjectButNotMuch(); 
     Db::transactional($this)->transactionalUpdate($result); //2. Next i am passing $this to Db class, to transactional method //4. It should run below transactionalUpdate method 
    } 

    public function transactionalUpdate(ImportantObjectButNotMuch $baconWithButter) 
    { 
     echo 'Do a lot of tricks...'; //5. It ends there, it is working but PhpStorm doesn't see it 
    } 
} 

EDIT APRÈS RÉPONSE:

@Nukeface et @Dmitry m'a fait venir avec la réponse à ma question: permet de voir à nouveau dans ma structure de fichiers:

class Db 
    { 
     public static function transactional($object) 
     { 
      return TransactionalProxy::newInstance($object); //3. It returns ApiObject object 
     } 
    } 

    class ApiObject 
    { 
     public function update_record() 
     { 
      //1. I am starting from there 
      $result = new ImportantObjectButNotMuch(); 
      //EDIT//Db::transactional($this)->transactionalUpdate($result); //2. Next i am passing $this to Db class, to transactional method //4. It should run below transactionalUpdate method 
      /** @var self $thisObject */ 
      //Line above informs PhpStorm that $thisObject is ApiObject indeed 
      $thisObject = Db::transactional($this) 
      $thisObject->transactionalUpdate($result); 
     } 

     public function transactionalUpdate(ImportantObjectButNotMuch $baconWithButter) 
     { 
      echo 'Do a lot of tricks...'; //5. It ends there, it is working but PhpStorm doesn't see it 
     } 
    } 

Answer 1

Vous devriez utiliser les Typehints. Mise à jour votre code ci-dessous:

/** 
* Class Db 
* @package Namespace\To\Db 
*/ 
class Db 
{ 

    /** 
    * @param $object 
    * @return ApiObject (per your line comment) 
    */ 
    public static function transactional($object) 
    { 
     return TransactionalProxy::newInstance($object); //3. It returns ApiObject object 
    } 
} 

/** 
* Class ApiObject 
* @package Namespace\To\ApiObject 
*/ 
class ApiObject 
{ 

    /** 
    * @return void (I see no "return" statement) 
    */ 
    public function update_record() 
    { 
     //1. I am starting from there 
     $result = new ImportantObjectButNotMuch(); 
     Db::transactional($this)->transactionalUpdate($result); //2. Next i am passing $this to Db class, to transactional method //4. It should run below transactionalUpdate method 
    } 

    /** 
    * @param ImportantObjectButNotMuch $baconWithButter 
    * @return void 
    */ 
    public function transactionalUpdate(ImportantObjectButNotMuch $baconWithButter) 
    { 
     echo 'Do a lot of tricks...'; //5. It ends there, it is working but PhpStorm doesn't see it 
    } 
} 

Vous pouvez rapidement créer docblocks et typehints de base en tapant /** puis en appuyant sur soit « enter » ou « espace ». Entrez si vous voulez un docblock et de l'espace si vous voulez un typehint.

Exemples de propre code ci-dessous:

/** 
* Class AbstractEventHandler 
* @package Hzw\Mvc\Event 
*/ 
abstract class AbstractEventHandler implements EventManagerAwareInterface 
{ 
    /** 
    * @var EventManagerInterface 
    */ 
    protected $events; 

    /** 
    * @var EntityManager|ObjectManager 
    */ 
    protected $entityManager; 

    /** 
    * AbstractEvent constructor. 
    * @param ObjectManager $entityManager 
    */ 
    public function __construct(ObjectManager $entityManager) 
    { 
     $this->setEntityManager($entityManager); 
    } 

    /** 
    * @param EventManagerInterface $events 
    */ 
    public function setEventManager(EventManagerInterface $events) 
    { 
     $events->setIdentifiers([ 
      __CLASS__, 
      get_class($this) 
     ]); 

     $this->events = $events; 
    } 

    /** 
    * @return EventManagerInterface 
    */ 
    public function getEventManager() 
    { 
     if (!$this->events) { 
      $this->setEventManager(new EventManager()); 
     } 

     return $this->events; 
    } 

    /** 
    * @return ObjectManager|EntityManager 
    */ 
    public function getEntityManager() 
    { 
     return $this->entityManager; 
    } 

    /** 
    * @param ObjectManager|EntityManager $entityManager 
    * @return AbstractEventHandler 
    */ 
    public function setEntityManager($entityManager) 
    { 
     $this->entityManager = $entityManager; 
     return $this; 
    } 
} 

Dans l'exemple ci-dessus, PhpStorm sait ce que chaque fonction exige et retourne. Il connaît les types et comme certains "return $this" il connaît la possibilité de chaîner des fonctions. En outre, l'exemple de code ci-dessus n'utilise que des "docblocks". Ci-dessous certains "typehints en ligne" à partir d'une fonction. Particulièrement utile quand il ne va pas être clair immédiatement ce qui va être retourné. De cette façon, encore une fois, PhpStorm sait où obtenir des fonctions, des options, etc. pour vous montrer.

/** @var AbstractForm $form */ 
$form = $this->getFormElementManager()->get($formName, (is_null($formOptions) ? [] : $formOptions)); 

/** @var Request $request */ 
$request = $this->getRequest(); 

Comme indice final. Si vous créez un groupe de propriétés pour une classe, comme dans mon exemple protected $events ou protected $entityManager, vous pouvez également générer les accesseurs &. Si vos propriétés contiennent les docblocks, il générera également les docblocks pour vous sur ces fonctions.

E.g. la propriété ci-dessous

/** 
* @var EntityManager|ObjectManager 
*/ 
protected $entityManager; 

Lorsque vous utilisez « Alt + Inser » vous obtenez un menu à l'emplacement du curseur. Choisissez "Getters/Setters".Dans la fenêtre pop-up, sélectionnez "entityManager" et cochez la case en bas de "setters". Ensuite, le code ci-dessous est généré pour vous:

/** 
* @return ObjectManager|EntityManager 
*/ 
public function getEntityManager() 
{ 
    return $this->entityManager; 
} 

/** 
* @param ObjectManager|EntityManager $entityManager 
* @return AbstractEventHandler 
*/ 
public function setEntityManager($entityManager) 
{ 
    $this->entityManager = $entityManager; 
    return $this; 
} 

Answer 2

La ferme chose que vous pouvez faire ce que vous voulez faire est d'utiliser @return avec plusieurs types.

/** 
* @param $object 
* @return ApiObject|AnotherApiObject|OneMoreApiObject 
*/ 
public static function transactional($object) 
{ 
    return TransactionalProxy::newInstance($object); 
}