[RFC] Lazy Objects

Zend/tests/lazy_objects/clone_calls___clone_once.phpt

@@ -0,0 +1,77 @@
+--TEST--
+Lazy objects: clone calls __clone() once
+--FILE--
+<?php
+
+class C {
+    public $a = 1;
+
+    public function __construct() {
+    }
+
+    public function __clone() {
+        var_dump("clone");
+    }
+}
+
+function test(string $name, object $obj) {
+    printf("# %s:\n", $name);
+
+    $reflector = new ReflectionClass($obj::class);
+    $clone = clone $obj;
+
+    var_dump($reflector->isUninitializedLazyObject($obj));
+    var_dump($obj);
+    var_dump($reflector->isUninitializedLazyObject($clone));
+    var_dump($clone);
+}
+
+$reflector = new ReflectionClass(C::class);
+
+$obj = $reflector->newLazyGhost(function ($obj) {
+    var_dump("initializer");
+    $obj->__construct();
+});
+
+test('Ghost', $obj);
+
+$obj = $reflector->newLazyProxy(function ($obj) {
+    var_dump("initializer");
+    return new C();
+});
+
+test('Proxy', $obj);
+
+--EXPECTF--
+# Ghost:
+string(11) "initializer"
+string(5) "clone"
+bool(false)
+object(C)#%d (1) {
+  ["a"]=>
+  int(1)
+}
+bool(false)
+object(C)#%d (1) {
+  ["a"]=>
+  int(1)
+}
+# Proxy:
+string(11) "initializer"
+string(5) "clone"
+bool(false)
+lazy proxy object(C)#%d (1) {
+  ["instance"]=>
+  object(C)#%d (1) {
+    ["a"]=>
+    int(1)
+  }
+}
+bool(false)
+lazy proxy object(C)#%d (1) {
+  ["instance"]=>
+  object(C)#%d (1) {
+    ["a"]=>
+    int(1)
+  }
+}

Zend/tests/lazy_objects/clone_creates_object_with_independent_state_001.phpt

@@ -0,0 +1,35 @@
+--TEST--
+Lazy objects: clone is independant of the original object
+--FILE--
+<?php
+
+class SomeObj {
+    public string $foo = 'A';
+    public string $dummy;
+}
+
+$reflector = new ReflectionClass(SomeObj::class);
+
+$predefinedObject = new SomeObj();
+$initializer = function () use ($predefinedObject) {
+    return $predefinedObject;
+};
+
+$myProxy = $reflector->newLazyProxy($initializer);
+$reflector->getProperty('foo')->skipLazyInitialization($myProxy);
+
+$clonedProxy = clone $myProxy;
+var_dump($clonedProxy->foo);
+
+$reflector->initializeLazyObject($myProxy);
+$myProxy->foo = 'B';
+
+$reflector->initializeLazyObject($clonedProxy);
+
+var_dump($myProxy->foo);
+var_dump($clonedProxy->foo);
+
+--EXPECT--
+string(1) "A"
+string(1) "B"
+string(1) "A"

Zend/tests/lazy_objects/clone_creates_object_with_independent_state_002.phpt

@@ -0,0 +1,56 @@
+--TEST--
+Lazy objects: clone is independant of the original object
+--FILE--
+<?php
+
+class SomeObj {
+    public Value $value;
+    public function __construct() {
+        $this->value = new Value();
+    }
+    public function __clone() {
+        $this->value = clone $this->value;
+    }
+}
+
+class Value {
+    public string $value = 'A';
+}
+
+function test(string $name, object $obj) {
+    printf("# %s:\n", $name);
+
+    $reflector = new ReflectionClass(SomeObj::class);
+
+    $clonedObj = clone $obj;
+    var_dump($clonedObj->value->value);
+
+    $reflector->initializeLazyObject($obj);
+    $obj->value->value = 'B';
+
+    $reflector->initializeLazyObject($clonedObj);
+
+    var_dump($obj->value->value);
+    var_dump($clonedObj->value->value);
+}
+
+$reflector = new ReflectionClass(SomeObj::class);
+
+test('Ghost', $reflector->newLazyGhost(function ($obj) {
+    $obj->__construct();
+}));
+
+test('Proxy', $reflector->newLazyProxy(function () {
+    return new SomeObj();
+}));
+
+?>
+--EXPECT--
+# Ghost:
+string(1) "A"
+string(1) "B"
+string(1) "A"
+# Proxy:
+string(1) "A"
+string(1) "B"
+string(1) "A"

Zend/tests/lazy_objects/clone_creates_object_with_independent_state_003.phpt

@@ -0,0 +1,40 @@
+--TEST--
+Lazy objects: clone is independant of the original object
+--FILE--
+<?php
+
+class SomeObj {
+    public string $foo = 'X';
+    public string $dummy;
+}
+
+function test(string $name, object $obj) {
+    printf("# %s:\n", $name);
+
+    $reflector = new ReflectionClass(SomeObj::class);
+
+    $clonedObj = clone $obj;
+
+    $reflector->initializeLazyObject($obj);
+    $reflector->getProperty('foo')->setRawValueWithoutLazyInitialization($clonedObj, 'Y');
+
+    $reflector->initializeLazyObject($clonedObj);
+
+    var_dump($clonedObj->foo);
+}
+
+$reflector = new ReflectionClass(SomeObj::class);
+
+test('Ghost', $reflector->newLazyGhost(function ($obj) {
+}));
+
+test('Proxy', $reflector->newLazyProxy(function () {
+    return new SomeObj();
+}));
+
+?>
+--EXPECT--
+# Ghost:
+string(1) "Y"
+# Proxy:
+string(1) "Y"

Zend/tests/lazy_objects/clone_initialized.phpt

@@ -0,0 +1,73 @@
+--TEST--
+Lazy objects: clone of initialized lazy object does not initialize twice
+--FILE--
+<?php
+
+class C {
+    public $a = 1;
+
+    public function __construct() {
+    }
+}
+
+function test(string $name, object $obj) {
+    printf("# %s:\n", $name);
+
+    $reflector = new ReflectionClass($obj::class);
+    $reflector->initializeLazyObject($obj);
+
+    $clone = clone $obj;
+
+    var_dump($reflector->isUninitializedLazyObject($obj));
+    var_dump($obj);
+    var_dump($reflector->isUninitializedLazyObject($clone));
+    var_dump($clone);
+}
+
+$reflector = new ReflectionClass(C::class);
+
+$obj = $reflector->newLazyGhost(function ($obj) {
+    var_dump("initializer");
+    $obj->__construct();
+});
+
+test('Ghost', $obj);
+
+$obj = $reflector->newLazyProxy(function ($obj) {
+    var_dump("initializer");
+    return new C();
+});
+
+test('Proxy', $obj);
+
+--EXPECTF--
+# Ghost:
+string(11) "initializer"
+bool(false)
+object(C)#%d (1) {
+  ["a"]=>
+  int(1)
+}
+bool(false)
+object(C)#%d (1) {
+  ["a"]=>
+  int(1)
+}
+# Proxy:
+string(11) "initializer"
+bool(false)
+lazy proxy object(C)#%d (1) {
+  ["instance"]=>
+  object(C)#%d (1) {
+    ["a"]=>
+    int(1)
+  }
+}
+bool(false)
+lazy proxy object(C)#%d (1) {
+  ["instance"]=>
+  object(C)#%d (1) {
+    ["a"]=>
+    int(1)
+  }
+}

Zend/tests/lazy_objects/clone_initializer_exception.phpt

@@ -0,0 +1,56 @@
+--TEST--
+Lazy objects: clone: initializer exception
+--FILE--
+<?php
+
+class C {
+    public $a = 1;
+
+    public function __construct() {
+    }
+
+    public function __destruct() {
+        var_dump(__METHOD__);
+    }
+}
+
+function test(string $name, object $obj) {
+    printf("# %s:\n", $name);
+
+    $reflector = new ReflectionClass($obj::class);
+
+    try {
+        $clone = clone $obj;
+    } catch (\Exception $e) {
+        printf("%s: %s\n", $e::class, $e->getMessage());
+    }
+
+    var_dump($reflector->isUninitializedLazyObject($obj));
+    var_dump($obj);
+}
+
+$reflector = new ReflectionClass(C::class);
+
+$obj = $reflector->newLazyGhost(function ($obj) {
+    throw new \Exception('initializer');
+});
+
+test('Ghost', $obj);
+
+$obj = $reflector->newLazyProxy(function ($obj) {
+    throw new \Exception('initializer');
+});
+
+test('Proxy', $obj);
+
+--EXPECTF--
+# Ghost:
+Exception: initializer
+bool(true)
+lazy ghost object(C)#%d (0) {
+}
+# Proxy:
+Exception: initializer
+bool(true)
+lazy proxy object(C)#%d (0) {
+}