Resolver helper issue with properties, inheritance and type hints

Jean-FrancoisHIVERT

When I use a combination of @ property + inheritance, the helper for autocompletion does not work correctly:

Make attention about the property $_HELPERS:

/**
  * @var \PhpCliShell\Application\Firewall\Controller\Address\Helper\Helpers
  */
  protected AbstractHelpers $_HELPERS;

HELPERS extends of AbstractHelpers but it is Address\Helper\Helpers instance (see the PHP doc)

Why we have AbstractHelpers? because the current class where we have this property extends of an abstract class common between many controller.

Now, we can see the controller rule is not resolved from the controllers helper:

When I remove the property type AbstractHelpers it works correctly:

Now check the HELPERS type:

Thank you for this fix.

Jean-FrancoisHIVERT

Hi, happy new year!

Any update about this issue?

Thank you.

Jean-FrancoisHIVERT

@JakubMisek Hi, I know it is a specific use case but have you time to check this issue please?
This impact our helper inherit system :-(

Thank you.

JakubMisek

Jean-FrancoisHIVERT Hi, and Happy New Year to you too!

I'll try to replicate the issue :)

JakubMisek

Jean-FrancoisHIVERT Can we have a more complete test case?

As I understand, there are

Helpers (with @property)
AbstractHelpers (with var $controllers?)
Controllers (with var $rule) ?

and

/** @var Helpers */
 protected AbstractHelpers $_HELPERS;

Does the AbstractPlugin matter? what's inside it?
Is $controllers defined somewhere else as well (using those generics)?

Thank you

So far, I have the following (but I don't know where to put the other $controllers):

<?php

namespace A\Helper {
    /**
     * @property Controllers $controllers
     */
    class Helpers extends \A\AbstractHelpers {
    }

    class Controllers {
        var $rule;
    }
}

namespace A {
    class AbstractHelpers {
        var $controller;
    }

    class Plugin {
        /**
         * @var \A\Helper\Helpers
         */
        protected AbstractHelpers $_HELPERS;

        function foo() {
            return $this->_HELPERS->controllers->rule;
        }
    }
}

Jean-FrancoisHIVERT

Ouccchhhh I spent 1h30 trying to reproduce this issue and found how to do that youpiii:

<?php
    namespace Devsense\Helper;

    /**
     * @property-read myClassA $myPropertyA
     */
    class myClassA {}

    /**
     * @property-read myClassB $myPropertyB
     */
    class myClassB {}

    /**
     * @property-read myClassA $myPropertyA
     */
    abstract class AbstractTest
    {
        public function __get(string $name)
        {
            return $this->_store[$name];
        }
    }

    /**
     * @property-read myClassB $myPropertyB
     */
    final class Test extends AbstractTest {}

    /**
     * @template P of AbstractPlugin
     */
    abstract class AbstractHelper
    {
        /**
         * @var P
         */
        public AbstractPlugin $plugin;
    }

    /**
     * @extends AbstractHelper<Plugin>
     */
    final class Helper extends AbstractHelper {}

    /**
     * @template T of AbstractTest
     */
    abstract class AbstractPlugin
    {
        /**
         * @var T
         */
        public AbstractTest $test;
    }

    /**
     * @extends AbstractPlugin<Test>
     */
    abstract class MyPlugin extends AbstractPlugin
    {
    }

    final class Plugin extends MyPlugin
    {
    }

    $helper = new Helper();
    $helper->plugin->test->myPropertyA->myPropertyA->myPropertyA;
    $helper->plugin->test->myPropertyB->myPropertyB->myPropertyB;

    function fctTestHelper(AbstractHelper $helper) {
    }

    fctTestHelper($helper);

    function fctTestPlugin(Plugin $plugin) {
    }

    fctTestPlugin($helper->plugin);

Be careful I don't understand why but, can you check the lines 69 and 70:

$helper->plugin->test->myPropertyA->myPropertyA->myPropertyA;
$helper->plugin->test->myPropertyB->myPropertyB->myPropertyB;

PHP Tools is able to resolve myPropertyA (loop is expected) but not myPropertyB.

If you remove the method __get in the class AbstractTest, it works and myPropertyB can be resolved in loop.

I tested in my project and if I remove a __get function in my helpers class, the resolver works correctly.
(The __get method has not any return type in this example but in my project there is one, removing it does not change anything)

Hope you will be able to find the bug with this example ^^
Thank you @JakubMisek

Jean-FrancoisHIVERT

Another thing that I don't understand @JakubMisek

If you remove the property type ligne 61 like this and you keep the __get method, the resolver works too:

        /**
         * @var T
         */
        public $test;

JakubMisek

awesome! thank you very much for your time @Jean-FrancoisHIVERT, I hope we'll get it working soon

JakubMisek

that's a wild test case!

anyways; it's caused by the ambiguity - test is both AbstractTest|Test, and both classes handle $myPropertyB. We merge that information into a single mixed type.

I'll try to make it fixed soon.

JakubMisek

pre-release 1.26.11954 changes how the $test property type is inferred, so it avoids ambiguity.

We'll keep improving this scenario since there're more things I've noticed :)

Jean-FrancoisHIVERT

@JakubMisek Hi thank you for this fix.

I confirm you, it works for some classes and in other location it does not work yet.

For your information, why I use this design? because PHP does not allow to override the properties types so if you have a base (abstract) class with a property of type generic and you want to override this property type when use the base class, it is not possible. It is always possible to override the constructor but not a property.

With generics and template, it is possible to do that for the resolver PHP tool.

Another solution is to do:

abstract class AbstractBase
{
    /**
     * @var AbstractHelpers
     */
    public AbstractHelpers $helpers;
    
    
    public function __construct(AbstractHelpers $helpers)
    {
        $this->helpers = $helpers;
    }
}

class Controller extends AbstractBase
{
    /**
     * @var MyHelpers
     */
    public AbstractHelpers $helpers;


    public function __construct(MyHelpers $helpers)
    {
        $this->helpers = $helpers;
    }
}

JakubMisek

Jean-FrancoisHIVERT I understand :)

That's why our type analysis failed - it did not expect the property ambiguity; hopefully fixed now

Preparing the pre-release

JakubMisek

fixed, thank you @Jean-FrancoisHIVERT

If there is more, please start a new topic :)