Is it possible to infer nested templates from within a plugin?

[veewee]

Hello,

Given this example: https://psalm.dev/r/f9aa48bf22

<?php
class X {
    public string $d = 'd';
}

/**
 * @template T of object
 */
class Accessor {

    /**
     * @param T $object
     */
    public function __construct(
        private object $object
    ){
    }

    /**
     * @param string $prop
     */
    public function get($prop): mixed
    {
        return get($this->object, $prop);
    }
}


/**
 * @template T of object
 * @param T $object
 * @param string $prop
 * @return T
 */
function get($object, $prop): mixed {
    /** @psalm-trace $object */
    return $object;
}

$a = get(new X, 'd');
$b = (new Accessor(new X))->get('d');

/** @psalm-trace $a, $b */

You can see that psalm results in:

INFO: Trace - 37:5 - $object: T:fn-get as object

INFO: Trace - 43:27 - $a: X
INFO: Trace - 43:27 - $b: mixed

I'm worndering why psalm is not able to infer that $b is X as well.
When I write a psalm plugin for detecting the return type of actual $object->{$prop}, I can infer the object argument to:

• For the $a case: TNamedObject
• For the $b case: TTemplateParam

(more information, see the provided plugin at: #9367 (comment))

Expand plugin code

use PhpParser\Node\Arg;
use Psalm\Internal\Codebase\Reflection;
use Psalm\Plugin\ArgTypeInferer;
use Psalm\Plugin\DynamicFunctionStorage;
use Psalm\Plugin\EventHandler\DynamicFunctionStorageProviderInterface;
use Psalm\Plugin\EventHandler\Event\DynamicFunctionStorageProviderEvent;
use Psalm\Storage\FunctionLikeParameter;
use Psalm\Type\Atomic;
use Psalm\Type\Atomic\TLiteralString;
use Psalm\Type\Atomic\TNamedObject;
use Psalm\Type\Atomic\TTemplateParam;
use Psalm\Type\Union;

class PropertyGetProvider implements DynamicFunctionStorageProviderInterface
{
  /**
   * @return array<lowercase-string>
   */
  public static function getFunctionIds(): array
  {
      return ['property_get'];
  }

  public static function getFunctionStorage(DynamicFunctionStorageProviderEvent $event): ?DynamicFunctionStorage
  {
      $args = $event->getArgs();
      $inferrer = $event->getArgTypeInferer();

      $objectType = self::inferObjectType($inferrer, $args[0]);
      if (!$objectType) {
          return null;
      }

      $propertyNameType = self::inferPropertyNameType($inferrer, $args[1]);
      if (!$propertyNameType) {
          return null;
      }

      try {
          $rc = new \ReflectionClass($objectType->value);
          $prop = $rc->getProperty($propertyNameType->value);
      } catch (\ReflectionException) {
          return null;
      }

      $inferredReturnType = Reflection::getPsalmTypeFromReflectionType($prop->getType());

      $storage = new DynamicFunctionStorage();
      $storage->params = [
          new FunctionLikeParameter('object', false, new Union([$objectType])),
          new FunctionLikeParameter('name', false, new Union([$propertyNameType])),
      ];
      $storage->return_type = $inferredReturnType;

      return $storage;
  }

  private static function inferObjectType(ArgTypeInferer $inferer, Arg $arg): TNamedObject | TTemplateParam | null
  {
      $objectTypeUnion = $inferer->infer($arg);
      if (!$objectTypeUnion->isSingle()) {
          return null;
      }

      /** @var TNamedObject | TTemplateParam | null $objectType */
      $objectType = $objectTypeUnion->getSingleAtomic();
      if (!$objectType->isNamedObjectType()) {
          return null;
      }

      return $objectType;
  }

  private static function inferPropertyNameType(ArgTypeInferer $inferer, Arg $arg): TLiteralString | null
  {
      $propertyNameTypeUnion = $inferer->infer($arg);
      if (!$propertyNameTypeUnion->isSingleStringLiteral()) {
          return null;
      }

      return $propertyNameTypeUnion->getSingleStringLiteral();
  }
}

Is it somehow possible from within a plugin to find the infered TNamedObject for the $b case as well?
Maybe this information is available or calculatable from somewhere in one of the various storages?
(This example contains an Accessor class, but it could as well be a higher-order function)

I recon this is not how the type-system works, but in this specific case it feels like it's something that should be calculateable - since the function argument is consuming a template that is resolvable from the parent's scope.

Any clues are highly welcome :)