Lazy proxies don't forward spl_object_id/spl_object_hash making userspace recursion detection unreliable

[jnvsor]

Description

Lazy proxies transparently forward all calls to the underlying instance, including things like get_class:

https://3v4l.org/QEXKP#v8.4.1

This transparency does not however extend to spl_object_id and spl_object_hash...

This makes recursion detection in userspace dumpers like symfony/var-dumper and kint-php/kint very difficult, since we have no other (fast) way of distinguishing object instances:

https://3v4l.org/Ad9CN#v8.4.1

In this simplified example we can see that while dumping $z correctly detects recursion after one "Loop", dumping $x takes two loops since the object id/hash of the contained proxy don't match the internal instance.

Lazy ghosts don't have this problem, but we don't have a userspace way of telling ghosts apart from proxies anyway.

PHP Version

PHP 8.4.1

Operating System

No response

[iluuu1994]

I'm not sure this qualifies as a bug, as I believe this is known. It might make sense to provide a function in reflection to fetch the backed object of a lazy propxy. /cc @arnaud-lb

[arnaud-lb]

The proxy and its real instance have distinct identities by design (and as specified in the RFC). Exposing the same identity for both objects has been considered, but it would create more problems. Most notably the proxy's identity would change during initialization. This would break code relying on identities.

For example, there is no good way to handle a case like this if proxies and real instances have the same identity:

$reflector = new ReflectionClass(C::class);

class C {
    public $prop;
}

$real = new C();
$proxy = $reflector->newLazyProxy(function () use (&$real) {
    return $real;
});

$map = new SplObjectStorage();
$map[$real] = 0;
$map[$proxy] = 1;

count($map); // int(2)

$reflector->initializeLazyObject($proxy);

count($map); // ???

get_class also does not forward to the real instance, for the same reason: The proxy's class would change during initialization.

Symfony VarDumper has special cases for Doctrine's and ProxyManager's proxies currently. I think that it makes sense for a var dumper to treat lazy objects in a special way (and to expose the fact that the object is lazy, and to dump the real instance nested in a proxy).

The Reflection API can help with that:

• We can find if an object is lazy with ReflectionClass::isUninitializedLazyObject()
• We can get the real instance of a proxy with ReflectionClass::initializeLazyObject() (It's a no-op if the object is initialized / not lazy, but it returns the real instance of proxies.).

$isLazy = $reflector->isUninitializedLazyObject($obj);
$realInstance = $isLazy ? null : $reflector->initializeLazyObject($obj);
$isInitializedProxy = !$isLazy && $realInstance !== $obj;

There is currently no way to distinguish an uninitialized ghost from an uninitialized proxy, however.

Other information that would be nice to expose in a var dumper:

• The initializer (ReflectionClass::getLazyInitializer())
• Whether a property is lazy (ReflectionProperty::isLazy())

[jnvsor]

We can get the real instance of a proxy with ReflectionClass::initializeLazyObject()

Ahh, this solves my use case. I'll go ahead and close this then