Implement WeakMap

RFC: https://wiki.php.net/rfc/weak_maps

diff --git a/UPGRADING b/UPGRADING
index 28454f24ed83d7eecf6ccfe656fb2ba760862337..886d1d4796ffba19d49c967bb6efcf5bb92d4613 100644 (file)
--- a/UPGRADING
+++ b/UPGRADING
@@ -330,6 +330,8 @@ PHP 8.0 UPGRADE NOTES
 - Core:
   . Added support for union types.
     RFC: https://wiki.php.net/rfc/union_types_v2
+  . Added WeakMap.
+    RFC: https://wiki.php.net/rfc/weak_maps
   . Added ValueError class.
 
 ========================================

diff --git a/Zend/tests/weakrefs/weakmap_basic_map_behavior.phpt b/Zend/tests/weakrefs/weakmap_basic_map_behavior.phpt
new file mode 100644 (file)
index 0000000..6eb283c
--- /dev/null
+++ b/Zend/tests/weakrefs/weakmap_basic_map_behavior.phpt
@@ -0,0 +1,173 @@
+--TEST--
+Basic WeakMap behavior (as a map)
+--FILE--
+<?php
+
+$map = new WeakMap;
+var_dump(count($map));
+
+$obj = new stdClass;
+$obj->value = 1;
+$obj2 = new stdClass;
+$obj2->value = 2;
+
+$map[$obj] = $obj2;
+var_dump(count($map));
+var_dump($map);
+var_dump(isset($map[$obj]));
+var_dump(!empty($map[$obj]));
+var_dump($map[$obj]);
+
+$map[$obj] = 42;
+var_dump($map);
+var_dump(isset($map[$obj]));
+var_dump(!empty($map[$obj]));
+var_dump($map[$obj]);
+
+$map[$obj] = false;
+var_dump($map);
+var_dump(isset($map[$obj]));
+var_dump(!empty($map[$obj]));
+var_dump($map[$obj]);
+
+$map[$obj] = null;
+var_dump($map);
+var_dump(isset($map[$obj]));
+var_dump(!empty($map[$obj]));
+var_dump($map[$obj]);
+
+unset($map[$obj]);
+var_dump($map);
+var_dump(isset($map[$obj]));
+var_dump(!empty($map[$obj]));
+try {
+    var_dump($map[$obj]);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "\nIndirect modification:\n";
+$map[$obj] = [];
+$map[$obj][] = 42;
+$map[$obj2] = 41;
+$map[$obj2]++;
+var_dump($map);
+
+echo "\nMethods:\n";
+var_dump($map->offsetSet($obj2, 43));
+var_dump($map->offsetGet($obj2));
+var_dump($map->offsetExists($obj2));
+var_dump($map->count());
+var_dump($map->offsetUnset($obj2));
+var_dump($map->count());
+
+?>
+--EXPECT--
+int(0)
+int(1)
+object(WeakMap)#1 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#2 (1) {
+      ["value"]=>
+      int(1)
+    }
+    ["value"]=>
+    object(stdClass)#3 (1) {
+      ["value"]=>
+      int(2)
+    }
+  }
+}
+bool(true)
+bool(true)
+object(stdClass)#3 (1) {
+  ["value"]=>
+  int(2)
+}
+object(WeakMap)#1 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#2 (1) {
+      ["value"]=>
+      int(1)
+    }
+    ["value"]=>
+    int(42)
+  }
+}
+bool(true)
+bool(true)
+int(42)
+object(WeakMap)#1 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#2 (1) {
+      ["value"]=>
+      int(1)
+    }
+    ["value"]=>
+    bool(false)
+  }
+}
+bool(true)
+bool(false)
+bool(false)
+object(WeakMap)#1 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#2 (1) {
+      ["value"]=>
+      int(1)
+    }
+    ["value"]=>
+    NULL
+  }
+}
+bool(false)
+bool(false)
+NULL
+object(WeakMap)#1 (0) {
+}
+bool(false)
+bool(false)
+Object stdClass#2 not contained in WeakMap
+
+Indirect modification:
+object(WeakMap)#1 (2) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#2 (1) {
+      ["value"]=>
+      int(1)
+    }
+    ["value"]=>
+    array(1) {
+      [0]=>
+      int(42)
+    }
+  }
+  [1]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#3 (1) {
+      ["value"]=>
+      int(2)
+    }
+    ["value"]=>
+    int(42)
+  }
+}
+
+Methods:
+NULL
+int(43)
+bool(true)
+int(2)
+NULL
+int(1)

diff --git a/Zend/tests/weakrefs/weakmap_error_conditions.phpt b/Zend/tests/weakrefs/weakmap_error_conditions.phpt
new file mode 100644 (file)
index 0000000..75a824f
--- /dev/null
+++ b/Zend/tests/weakrefs/weakmap_error_conditions.phpt
@@ -0,0 +1,96 @@
+--TEST--
+WeakMap error conditions
+--FILE--
+<?php
+
+$map = new WeakMap;
+try {
+    $map[1] = 2;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump($map[1]);
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    isset($map[1]);
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    unset($map[1]);
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+try {
+    $map[] = 1;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    $map[][1] = 1;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump($map[new stdClass]);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+try {
+    $map->prop = 1;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump($map->prop);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    $r =& $map->prop;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    isset($map->prop);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    unset($map->prop);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+try {
+    serialize($map);
+} catch (Exception $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    unserialize('C:7:"WeakMap":0:{}');
+} catch (Exception $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+WeakMap key must be an object
+WeakMap key must be an object
+WeakMap key must be an object
+WeakMap key must be an object
+Cannot append to WeakMap
+Cannot append to WeakMap
+Object stdClass#2 not contained in WeakMap
+WeakMap objects do not support properties
+WeakMap objects do not support properties
+WeakMap objects do not support property references
+WeakMap objects do not support properties
+WeakMap objects do not support properties
+Serialization of 'WeakMap' is not allowed
+Unserialization of 'WeakMap' is not allowed

diff --git a/Zend/tests/weakrefs/weakmap_iteration.phpt b/Zend/tests/weakrefs/weakmap_iteration.phpt
new file mode 100644 (file)
index 0000000..1d1f6de
--- /dev/null
+++ b/Zend/tests/weakrefs/weakmap_iteration.phpt
@@ -0,0 +1,80 @@
+--TEST--
+WeakMap iteration
+--FILE--
+<?php
+
+$map = new WeakMap;
+
+echo "\nEmpty loop:\n";
+foreach ($map as $key => $value) {
+    var_dump($key, $value);
+}
+
+echo "\nSimple loop:\n";
+$obj0 = new stdClass;
+$obj1 = new stdClass;
+$obj2 = new stdClass;
+$map[$obj0] = 0;
+$map[$obj1] = 1;
+$map[$obj2] = 2;
+foreach ($map as $key => $value) {
+    var_dump($key, $value);
+}
+
+echo "\nObject removed during loop:\n";
+foreach ($map as $key => $value) {
+    if (isset($obj1) && $key === $obj1) unset($obj1);
+    var_dump($key, $value);
+}
+
+echo "\nBy reference iteration:\n";
+foreach ($map as $key => &$value) {
+    $value++;
+}
+var_dump($map);
+
+?>
+--EXPECT--
+Empty loop:
+
+Simple loop:
+object(stdClass)#2 (0) {
+}
+int(0)
+object(stdClass)#3 (0) {
+}
+int(1)
+object(stdClass)#4 (0) {
+}
+int(2)
+
+Object removed during loop:
+object(stdClass)#2 (0) {
+}
+int(0)
+object(stdClass)#3 (0) {
+}
+int(1)
+object(stdClass)#4 (0) {
+}
+int(2)
+
+By reference iteration:
+object(WeakMap)#1 (2) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#2 (0) {
+    }
+    ["value"]=>
+    &int(1)
+  }
+  [1]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#4 (0) {
+    }
+    ["value"]=>
+    &int(3)
+  }
+}

diff --git a/Zend/tests/weakrefs/weakmap_multiple_weakrefs.phpt b/Zend/tests/weakrefs/weakmap_multiple_weakrefs.phpt
new file mode 100644 (file)
index 0000000..c3a1eda
--- /dev/null
+++ b/Zend/tests/weakrefs/weakmap_multiple_weakrefs.phpt
@@ -0,0 +1,74 @@
+--TEST--
+Multiple WeakMaps / WeakRefs on the same object
+--FILE--
+<?php
+
+$obj = new stdClass;
+
+$ref = WeakReference::create($obj);
+$map = new WeakMap;
+$map[$obj] = 1;
+$map2 = new WeakMap;
+$map2[$obj] = 1;
+$map3 = clone $map2;
+
+var_dump($ref->get(), $map, $map2, $map3);
+unset($obj);
+var_dump($ref->get(), $map, $map2, $map3);
+unset($ref, $map, $map2);
+
+$obj = new stdClass;
+$ref = WeakReference::create($obj);
+$map = new WeakMap;
+$map[$obj] = 1;
+$map2 = new WeakMap;
+$map2[$obj] = 1;
+$map3 = clone $map2;
+
+unset($ref, $map, $map2, $map3);
+var_dump($obj);
+unset($obj);
+
+?>
+--EXPECT--
+object(stdClass)#1 (0) {
+}
+object(WeakMap)#3 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#1 (0) {
+    }
+    ["value"]=>
+    int(1)
+  }
+}
+object(WeakMap)#4 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#1 (0) {
+    }
+    ["value"]=>
+    int(1)
+  }
+}
+object(WeakMap)#5 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#1 (0) {
+    }
+    ["value"]=>
+    int(1)
+  }
+}
+NULL
+object(WeakMap)#3 (0) {
+}
+object(WeakMap)#4 (0) {
+}
+object(WeakMap)#5 (0) {
+}
+object(stdClass)#4 (0) {
+}

diff --git a/Zend/tests/weakrefs/weakmap_weakness.phpt b/Zend/tests/weakrefs/weakmap_weakness.phpt
new file mode 100644 (file)
index 0000000..5e57dea
--- /dev/null
+++ b/Zend/tests/weakrefs/weakmap_weakness.phpt
@@ -0,0 +1,107 @@
+--TEST--
+The weak part of the WeakMap
+--FILE--
+<?php
+
+$map = new WeakMap;
+
+// This is doing to be inserted into the map and immediately removed again
+$map[new stdClass] = 1;
+var_dump($map);
+
+$obj = new stdClass;
+$map[$obj] = 2;
+var_dump($map);
+
+unset($obj);
+var_dump($map);
+
+echo "\nDestructor in WeakMap value:\n";
+$obj = new stdClass;
+$map[$obj] = new class {
+    public function __destruct() {
+        echo "Dtor!\n";
+    }
+};
+
+echo "Before unset:\n";
+unset($obj);
+echo "After unset:\n";
+var_dump($map);
+
+echo "\nDestroying map with live object:\n";
+$obj = new stdClass;
+$map[$obj] = 3;
+unset($map);
+var_dump($obj);
+
+echo "\nObject freed by GC:\n";
+$map = new WeakMap;
+$obj = new stdClass;
+$obj->obj = $obj;
+$map[$obj] = 4;
+unset($obj);
+var_dump($map);
+gc_collect_cycles();
+var_dump($map);
+
+echo "\nStoring map in itself:\n";
+$map = new WeakMap;
+$map[$map] = $map;
+var_dump($map);
+unset($map);
+
+?>
+--EXPECT--
+object(WeakMap)#1 (0) {
+}
+object(WeakMap)#1 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#2 (0) {
+    }
+    ["value"]=>
+    int(2)
+  }
+}
+object(WeakMap)#1 (0) {
+}
+
+Destructor in WeakMap value:
+Before unset:
+Dtor!
+After unset:
+object(WeakMap)#1 (0) {
+}
+
+Destroying map with live object:
+object(stdClass)#2 (0) {
+}
+
+Object freed by GC:
+object(WeakMap)#1 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    object(stdClass)#3 (1) {
+      ["obj"]=>
+      *RECURSION*
+    }
+    ["value"]=>
+    int(4)
+  }
+}
+object(WeakMap)#1 (0) {
+}
+
+Storing map in itself:
+object(WeakMap)#3 (1) {
+  [0]=>
+  array(2) {
+    ["key"]=>
+    *RECURSION*
+    ["value"]=>
+    *RECURSION*
+  }
+}

diff --git a/Zend/zend_weakrefs.c b/Zend/zend_weakrefs.c
index d7531af285f2374d98f09c826e4d38227c4d3da5..c3f7bf5bb2f15f18b4b1d2ba01c7a2b26daf311e 100644 (file)
--- a/Zend/zend_weakrefs.c
+++ b/Zend/zend_weakrefs.c
@@ -25,29 +25,145 @@ typedef struct _zend_weakref {
        zend_object std;
 } zend_weakref;
 
+typedef struct _zend_weakmap {
+       HashTable ht;
+       zend_object std;
+} zend_weakmap;
+
+typedef struct _zend_weakmap_iterator {
+       zend_object_iterator it;
+       uint32_t ht_iter;
+} zend_weakmap_iterator;
+
+/* The EG(weakrefs) ht is a map from object address a tagged pointer, that may be one of
+ * zend_weakref*, zend_weakmap* or HashTable*. */
+#define ZEND_WEAKREF_TAG_REF 0
+#define ZEND_WEAKREF_TAG_MAP 1
+#define ZEND_WEAKREF_TAG_HT  2
+#define ZEND_WEAKREF_GET_TAG(p) (((uintptr_t) (p)) & 3)
+#define ZEND_WEAKREF_GET_PTR(p) ((void *) (((uintptr_t) (p)) & ~3))
+#define ZEND_WEAKREF_ENCODE(p, t) ((void *) (((uintptr_t) (p)) | (t)))
+
 zend_class_entry *zend_ce_weakref;
+zend_class_entry *zend_ce_weakmap;
 static zend_object_handlers zend_weakref_handlers;
+static zend_object_handlers zend_weakmap_handlers;
 
 #define zend_weakref_from(o) ((zend_weakref*)(((char*) o) - XtOffsetOf(zend_weakref, std)))
 #define zend_weakref_fetch(z) zend_weakref_from(Z_OBJ_P(z))
 
-static void zend_weakref_unref(zval *zv) {
-       zend_weakref *wr = (zend_weakref*) Z_PTR_P(zv);
+#define zend_weakmap_from(o) ((zend_weakmap*)(((char*) o) - XtOffsetOf(zend_weakmap, std)))
+#define zend_weakmap_fetch(z) zend_weakmap_from(Z_OBJ_P(z))
 
-       GC_DEL_FLAGS(wr->referent, IS_OBJ_WEAKLY_REFERENCED);
+static inline void zend_weakref_unref_single(
+               void *ptr, uintptr_t tag, zend_ulong obj_addr)
+{
+       if (tag == ZEND_WEAKREF_TAG_REF) {
+               zend_weakref *wr = ptr;
+               wr->referent = NULL;
+       } else {
+               ZEND_ASSERT(tag == ZEND_WEAKREF_TAG_MAP);
+               zend_weakmap *wm = ptr;
+               zend_hash_index_del(&wm->ht, obj_addr);
+       }
+}
 
-       wr->referent = NULL;
+static void zend_weakref_unref(zend_ulong obj_addr, void *tagged_ptr) {
+       void *ptr = ZEND_WEAKREF_GET_PTR(tagged_ptr);
+       uintptr_t tag = ZEND_WEAKREF_GET_TAG(tagged_ptr);
+       if (tag == ZEND_WEAKREF_TAG_HT) {
+               HashTable *ht = ptr;
+               ZEND_HASH_FOREACH_PTR(ht, tagged_ptr) {
+                       zend_weakref_unref_single(
+                               ZEND_WEAKREF_GET_PTR(tagged_ptr), ZEND_WEAKREF_GET_TAG(tagged_ptr), obj_addr);
+               } ZEND_HASH_FOREACH_END();
+               zend_hash_destroy(ht);
+               FREE_HASHTABLE(ht);
+       } else {
+               zend_weakref_unref_single(ptr, tag, obj_addr);
+       }
+}
+
+static void zend_weakref_register(zend_object *object, void *payload) {
+       GC_ADD_FLAGS(object, IS_OBJ_WEAKLY_REFERENCED);
+
+       zend_ulong obj_addr = (zend_ulong) object;
+       zval *zv = zend_hash_index_find(&EG(weakrefs), obj_addr);
+       if (!zv) {
+               zend_hash_index_add_new_ptr(&EG(weakrefs), obj_addr, payload);
+               return;
+       }
+
+       void *tagged_ptr = Z_PTR_P(zv);
+       if (ZEND_WEAKREF_GET_TAG(tagged_ptr) == ZEND_WEAKREF_TAG_HT) {
+               HashTable *ht = ZEND_WEAKREF_GET_PTR(tagged_ptr);
+               zend_hash_index_add_new_ptr(ht, (zend_ulong) payload, payload);
+               return;
+       }
+
+       /* Convert simple pointer to hashtable. */
+       HashTable *ht = emalloc(sizeof(HashTable));
+       zend_hash_init(ht, 0, NULL, NULL, 0);
+       zend_hash_index_add_new_ptr(ht, (zend_ulong) tagged_ptr, tagged_ptr);
+       zend_hash_index_add_new_ptr(ht, (zend_ulong) payload, payload);
+       zend_hash_index_update_ptr(
+               &EG(weakrefs), obj_addr, ZEND_WEAKREF_ENCODE(ht, ZEND_WEAKREF_TAG_HT));
+}
+
+static void zend_weakref_unregister(zend_object *object, void *payload) {
+       zend_ulong obj_addr = (zend_ulong) object;
+       void *tagged_ptr = zend_hash_index_find_ptr(&EG(weakrefs), obj_addr);
+       ZEND_ASSERT(tagged_ptr && "Weakref not registered?");
+
+       void *ptr = ZEND_WEAKREF_GET_PTR(tagged_ptr);
+       uintptr_t tag = ZEND_WEAKREF_GET_TAG(tagged_ptr);
+       if (tag != ZEND_WEAKREF_TAG_HT) {
+               ZEND_ASSERT(tagged_ptr == payload);
+               zend_weakref_unref_single(ptr, tag, obj_addr);
+               zend_hash_index_del(&EG(weakrefs), obj_addr);
+               GC_DEL_FLAGS(object, IS_OBJ_WEAKLY_REFERENCED);
+               return;
+       }
+
+       HashTable *ht = ptr;
+       tagged_ptr = zend_hash_index_find_ptr(ht, (zend_ulong) payload);
+       ZEND_ASSERT(tagged_ptr && "Weakref not registered?");
+       ZEND_ASSERT(tagged_ptr == payload);
+       zend_weakref_unref_single(
+               ZEND_WEAKREF_GET_PTR(payload), ZEND_WEAKREF_GET_TAG(payload), obj_addr);
+       zend_hash_index_del(ht, (zend_ulong) payload);
+       if (zend_hash_num_elements(ht) == 0) {
+               GC_DEL_FLAGS(object, IS_OBJ_WEAKLY_REFERENCED);
+               zend_hash_destroy(ht);
+               FREE_HASHTABLE(ht);
+               zend_hash_index_del(&EG(weakrefs), obj_addr);
+       }
 }
 
 void zend_weakrefs_init() {
-       zend_hash_init(&EG(weakrefs), 8, NULL, zend_weakref_unref, 0);
+       zend_hash_init(&EG(weakrefs), 8, NULL, NULL, 0);
 }
 
 void zend_weakrefs_notify(zend_object *object) {
-       zend_hash_index_del(&EG(weakrefs), (zend_ulong) object);
+       /* Annoyingly we can't use the HT destructor here, because we need access to the key (which
+        * is the object address), which is not provided to the dtor. */
+       zend_ulong obj_addr = (zend_ulong) object;
+       void *tagged_ptr = zend_hash_index_find_ptr(&EG(weakrefs), obj_addr);
+#if ZEND_DEBUG
+       ZEND_ASSERT(tagged_ptr && "Tracking of the IS_OBJ_WEAKLY_REFERENCE flag should be precise");
+#endif
+       if (tagged_ptr) {
+               zend_weakref_unref(obj_addr, tagged_ptr);
+               zend_hash_index_del(&EG(weakrefs), obj_addr);
+       }
 }
 
 void zend_weakrefs_shutdown() {
+       zend_ulong obj_addr;
+       void *tagged_ptr;
+       ZEND_HASH_FOREACH_NUM_KEY_PTR(&EG(weakrefs), obj_addr, tagged_ptr) {
+               zend_weakref_unref(obj_addr, tagged_ptr);
+       } ZEND_HASH_FOREACH_END();
        zend_hash_destroy(&EG(weakrefs));
 }
 
@@ -62,16 +178,32 @@ static zend_object* zend_weakref_new(zend_class_entry *ce) {
 }
 
 static zend_always_inline zend_bool zend_weakref_find(zval *referent, zval *return_value) {
-       zend_weakref *wr = zend_hash_index_find_ptr(&EG(weakrefs), (zend_ulong) Z_OBJ_P(referent));
-
-       if (!wr) {
+       void *tagged_ptr = zend_hash_index_find_ptr(&EG(weakrefs), (zend_ulong) Z_OBJ_P(referent));
+       if (!tagged_ptr) {
                return 0;
        }
 
-       GC_ADDREF(&wr->std);
-       ZVAL_OBJ(return_value, &wr->std);
+       void *ptr = ZEND_WEAKREF_GET_PTR(tagged_ptr);
+       uintptr_t tag = ZEND_WEAKREF_GET_TAG(tagged_ptr);
+       if (tag == ZEND_WEAKREF_TAG_REF) {
+               zend_weakref *wr;
+found_weakref:
+               wr = ptr;
+               GC_ADDREF(&wr->std);
+               ZVAL_OBJ(return_value, &wr->std);
+               return 1;
+       }
 
-       return 1;
+       if (tag == ZEND_WEAKREF_TAG_HT) {
+               ZEND_HASH_FOREACH(ptr, tagged_ptr) {
+                       if (ZEND_WEAKREF_GET_TAG(tagged_ptr) == ZEND_WEAKREF_TAG_REF) {
+                               ptr = ZEND_WEAKREF_GET_PTR(tagged_ptr);
+                               goto found_weakref;
+                       }
+               } ZEND_HASH_FOREACH_END();
+       }
+
+       return 0;
 }
 
 static zend_always_inline void zend_weakref_create(zval *referent, zval *return_value) {
@@ -80,12 +212,9 @@ static zend_always_inline void zend_weakref_create(zval *referent, zval *return_
        object_init_ex(return_value, zend_ce_weakref);
 
        wr = zend_weakref_fetch(return_value);
-
        wr->referent = Z_OBJ_P(referent);
 
-       zend_hash_index_add_ptr(&EG(weakrefs), (zend_ulong) wr->referent, wr);
-
-       GC_ADD_FLAGS(wr->referent, IS_OBJ_WEAKLY_REFERENCED);
+       zend_weakref_register(wr->referent, ZEND_WEAKREF_ENCODE(wr, ZEND_WEAKREF_TAG_REF));
 }
 
 static zend_always_inline void zend_weakref_get(zval *weakref, zval *return_value) {
@@ -101,44 +230,43 @@ static void zend_weakref_free(zend_object *zo) {
        zend_weakref *wr = zend_weakref_from(zo);
 
        if (wr->referent) {
-               zend_hash_index_del(
-                       &EG(weakrefs), (zend_ulong) wr->referent);
+               zend_weakref_unregister(wr->referent, ZEND_WEAKREF_ENCODE(wr, ZEND_WEAKREF_TAG_REF));
        }
 
        zend_object_std_dtor(&wr->std);
 }
 
-#define zend_weakref_unsupported(thing) \
-       zend_throw_error(NULL, "WeakReference objects do not support " thing);
+#define zend_weakref_unsupported(object, thing) \
+       zend_throw_error(NULL, "%s objects do not support " thing, ZSTR_VAL(object->ce->name));
 
 static ZEND_COLD zval* zend_weakref_no_write(zend_object *object, zend_string *member, zval *value, void **rtc) {
-       zend_weakref_unsupported("properties");
+       zend_weakref_unsupported(object, "properties");
 
        return &EG(uninitialized_zval);
 }
 
 static ZEND_COLD zval* zend_weakref_no_read(zend_object *object, zend_string *member, int type, void **rtc, zval *rv) {
        if (!EG(exception)) {
-               zend_weakref_unsupported("properties");
+               zend_weakref_unsupported(object, "properties");
        }
 
        return &EG(uninitialized_zval);
 }
 
 static ZEND_COLD zval *zend_weakref_no_read_ptr(zend_object *object, zend_string *member, int type, void **rtc) {
-       zend_weakref_unsupported("property references");
+       zend_weakref_unsupported(object, "property references");
        return NULL;
 }
 
 static ZEND_COLD int zend_weakref_no_isset(zend_object *object, zend_string *member, int hse, void **rtc) {
        if (hse != 2) {
-               zend_weakref_unsupported("properties");
+               zend_weakref_unsupported(object, "properties");
        }
        return 0;
 }
 
 static ZEND_COLD void zend_weakref_no_unset(zend_object *object, zend_string *member, void **rtc) {
-       zend_weakref_unsupported("properties");
+       zend_weakref_unsupported(object, "properties");
 }
 
 ZEND_COLD ZEND_METHOD(WeakReference, __construct)
@@ -177,6 +305,330 @@ static const zend_function_entry zend_weakref_methods[] = {
        ZEND_FE_END
 };
 
+static zend_object *zend_weakmap_create_object(zend_class_entry *ce)
+{
+       zend_weakmap *wm = zend_object_alloc(sizeof(zend_weakmap), ce);
+       zend_object_std_init(&wm->std, ce);
+       wm->std.handlers = &zend_weakmap_handlers;
+
+       zend_hash_init(&wm->ht, 0, NULL, ZVAL_PTR_DTOR, 0);
+       return &wm->std;
+}
+
+static void zend_weakmap_free_obj(zend_object *object)
+{
+       zend_weakmap *wm = zend_weakmap_from(object);
+       zend_ulong obj_addr;
+       ZEND_HASH_FOREACH_NUM_KEY(&wm->ht, obj_addr) {
+               zend_weakref_unregister(
+                       (zend_object *) obj_addr, ZEND_WEAKREF_ENCODE(wm, ZEND_WEAKREF_TAG_MAP));
+       } ZEND_HASH_FOREACH_END();
+       zend_hash_destroy(&wm->ht);
+       zend_object_std_dtor(&wm->std);
+}
+
+static zval *zend_weakmap_read_dimension(zend_object *object, zval *offset, int type, zval *rv)
+{
+       if (offset == NULL) {
+               zend_throw_error(NULL, "Cannot append to WeakMap");
+               return NULL;
+       }
+
+       if (Z_TYPE_P(offset) != IS_OBJECT) {
+               zend_type_error("WeakMap key must be an object");
+               return NULL;
+       }
+
+       zend_weakmap *wm = zend_weakmap_from(object);
+       zend_object *obj_key = Z_OBJ_P(offset);
+       zval *zv = zend_hash_index_find(&wm->ht, (zend_ulong) obj_key);
+       if (zv == NULL) {
+               if (type != BP_VAR_IS) {
+                       zend_throw_error(NULL,
+                               "Object %s#%d not contained in WeakMap", ZSTR_VAL(obj_key->ce->name), obj_key->handle);
+                       return NULL;
+               }
+               return NULL;
+       }
+
+       if (type == BP_VAR_W || type == BP_VAR_RW) {
+               ZVAL_MAKE_REF(zv);
+       }
+       return zv;
+}
+
+static void zend_weakmap_write_dimension(zend_object *object, zval *offset, zval *value)
+{
+       if (offset == NULL) {
+               zend_throw_error(NULL, "Cannot append to WeakMap");
+               return;
+       }
+
+       if (Z_TYPE_P(offset) != IS_OBJECT) {
+               zend_type_error("WeakMap key must be an object");
+               return;
+       }
+
+       zend_weakmap *wm = zend_weakmap_from(object);
+       zend_object *obj_key = Z_OBJ_P(offset);
+       Z_TRY_ADDREF_P(value);
+
+       zval *zv = zend_hash_index_find(&wm->ht, (zend_ulong) obj_key);
+       if (zv) {
+               zval_ptr_dtor(zv);
+               ZVAL_COPY_VALUE(zv, value);
+               return;
+       }
+
+       zend_weakref_register(obj_key, ZEND_WEAKREF_ENCODE(wm, ZEND_WEAKREF_TAG_MAP));
+       zend_hash_index_add_new(&wm->ht, (zend_ulong) obj_key, value);
+}
+
+static int zend_weakmap_has_dimension(zend_object *object, zval *offset, int check_empty)
+{
+       if (Z_TYPE_P(offset) != IS_OBJECT) {
+               zend_type_error("WeakMap key must be an object");
+               return 0;
+       }
+
+       zend_weakmap *wm = zend_weakmap_from(object);
+       zval *zv = zend_hash_index_find(&wm->ht, (zend_ulong) Z_OBJ_P(offset));
+       if (!zv) {
+               return 0;
+       }
+
+       if (check_empty) {
+               return i_zend_is_true(zv);
+       }
+       return Z_TYPE_P(zv) != IS_NULL;
+}
+
+static void zend_weakmap_unset_dimension(zend_object *object, zval *offset)
+{
+       if (Z_TYPE_P(offset) != IS_OBJECT) {
+               zend_type_error("WeakMap key must be an object");
+               return;
+       }
+
+       zend_weakmap *wm = zend_weakmap_from(object);
+       zend_object *obj_key = Z_OBJ_P(offset);
+       zend_weakref_unregister(obj_key, ZEND_WEAKREF_ENCODE(wm, ZEND_WEAKREF_TAG_MAP));
+}
+
+static int zend_weakmap_count_elements(zend_object *object, zend_long *count)
+{
+       zend_weakmap *wm = zend_weakmap_from(object);
+       *count = zend_hash_num_elements(&wm->ht);
+       return SUCCESS;
+}
+
+static HashTable *zend_weakmap_get_properties_for(zend_object *object, zend_prop_purpose purpose)
+{
+       if (purpose != ZEND_PROP_PURPOSE_DEBUG) {
+               return NULL;
+       }
+
+       zend_weakmap *wm = zend_weakmap_from(object);
+       HashTable *ht;
+       ALLOC_HASHTABLE(ht);
+       zend_hash_init(ht, zend_hash_num_elements(&wm->ht), NULL, ZVAL_PTR_DTOR, 0);
+
+       zend_ulong obj_addr;
+       zval *val;
+       ZEND_HASH_FOREACH_NUM_KEY_VAL(&wm->ht, obj_addr, val) {
+               zval pair;
+               zval obj_zv;
+               array_init(&pair);
+
+               ZVAL_OBJ(&obj_zv, (zend_object *) obj_addr);
+               Z_ADDREF(obj_zv);
+               add_assoc_zval(&pair, "key", &obj_zv);
+               Z_TRY_ADDREF_P(val);
+               add_assoc_zval(&pair, "value", val);
+
+               zend_hash_next_index_insert(ht, &pair);
+       } ZEND_HASH_FOREACH_END();
+
+       return ht;
+}
+
+static HashTable *zend_weakmap_get_gc(zend_object *object, zval **table, int *n)
+{
+       zend_weakmap *wm = zend_weakmap_from(object);
+       *table = NULL;
+       *n = 0;
+       return &wm->ht;
+}
+
+static zend_object *zend_weakmap_clone_obj(zend_object *old_object)
+{
+       zend_object *new_object = zend_weakmap_create_object(zend_ce_weakmap);
+       zend_weakmap *old_wm = zend_weakmap_from(old_object);
+       zend_weakmap *new_wm = zend_weakmap_from(new_object);
+       zend_hash_copy(&new_wm->ht, &old_wm->ht, NULL);
+
+       zend_ulong obj_addr;
+       zval *val;
+       ZEND_HASH_FOREACH_NUM_KEY_VAL(&new_wm->ht, obj_addr, val) {
+               zend_weakref_register(
+                       (zend_object *) obj_addr, ZEND_WEAKREF_ENCODE(new_wm, ZEND_WEAKREF_TAG_MAP));
+               zval_add_ref(val);
+       } ZEND_HASH_FOREACH_END();
+       return new_object;
+}
+
+static HashPosition *zend_weakmap_iterator_get_pos_ptr(zend_weakmap_iterator *iter) {
+       ZEND_ASSERT(iter->ht_iter != (uint32_t) -1);
+       return &EG(ht_iterators)[iter->ht_iter].pos;
+}
+
+static void zend_weakmap_iterator_dtor(zend_object_iterator *obj_iter)
+{
+       zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter;
+       zend_hash_iterator_del(iter->ht_iter);
+       zval_ptr_dtor(&iter->it.data);
+}
+
+static int zend_weakmap_iterator_valid(zend_object_iterator *obj_iter)
+{
+       zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter;
+       zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data);
+       HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter);
+       return zend_hash_has_more_elements_ex(&wm->ht, pos);
+}
+
+static zval *zend_weakmap_iterator_get_current_data(zend_object_iterator *obj_iter)
+{
+       zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter;
+       zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data);
+       HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter);
+       return zend_hash_get_current_data_ex(&wm->ht, pos);
+}
+
+static void zend_weakmap_iterator_get_current_key(zend_object_iterator *obj_iter, zval *key)
+{
+       zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter;
+       zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data);
+       HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter);
+
+       zend_string *string_key;
+       zend_ulong num_key;
+       int key_type = zend_hash_get_current_key_ex(&wm->ht, &string_key, &num_key, pos);
+       if (key_type != HASH_KEY_IS_LONG) {
+               ZEND_ASSERT(0 && "Must have integer key");
+       }
+
+       ZVAL_OBJ(key, (zend_object *) num_key);
+       Z_ADDREF_P(key);
+}
+
+static void zend_weakmap_iterator_move_forward(zend_object_iterator *obj_iter)
+{
+       zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter;
+       zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data);
+       HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter);
+       zend_hash_move_forward_ex(&wm->ht, pos);
+}
+
+static void zend_weakmap_iterator_rewind(zend_object_iterator *obj_iter)
+{
+       zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter;
+       zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data);
+       HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter);
+       zend_hash_internal_pointer_reset_ex(&wm->ht, pos);
+}
+
+static const zend_object_iterator_funcs zend_weakmap_iterator_funcs = {
+       zend_weakmap_iterator_dtor,
+       zend_weakmap_iterator_valid,
+       zend_weakmap_iterator_get_current_data,
+       zend_weakmap_iterator_get_current_key,
+       zend_weakmap_iterator_move_forward,
+       zend_weakmap_iterator_rewind,
+       NULL
+};
+
+static zend_object_iterator *zend_weakmap_get_iterator(
+               zend_class_entry *ce, zval *object, int by_ref)
+{
+       zend_weakmap *wm = zend_weakmap_fetch(object);
+       zend_weakmap_iterator *iter = emalloc(sizeof(zend_weakmap_iterator));
+       zend_iterator_init(&iter->it);
+       iter->it.funcs = &zend_weakmap_iterator_funcs;
+       ZVAL_COPY(&iter->it.data, object);
+       iter->ht_iter = zend_hash_iterator_add(&wm->ht, 0);
+       return &iter->it;
+}
+
+ZEND_METHOD(WeakMap, offsetGet)
+{
+       zval *key;
+
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &key) == FAILURE) {
+               return;
+       }
+
+       zval *zv = zend_weakmap_read_dimension(Z_OBJ_P(ZEND_THIS), key, BP_VAR_R, NULL);
+       if (!zv) {
+               return;
+       }
+
+       ZVAL_COPY(return_value, zv);
+}
+
+ZEND_METHOD(WeakMap, offsetSet)
+{
+       zval *key, *value;
+
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &key, &value) == FAILURE) {
+               return;
+       }
+
+       zend_weakmap_write_dimension(Z_OBJ_P(ZEND_THIS), key, value);
+}
+
+ZEND_METHOD(WeakMap, offsetExists)
+{
+       zval *key;
+
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &key) == FAILURE) {
+               return;
+       }
+
+       RETURN_BOOL(zend_weakmap_has_dimension(Z_OBJ_P(ZEND_THIS), key, /* check_empty */ 0));
+}
+
+ZEND_METHOD(WeakMap, offsetUnset)
+{
+       zval *key;
+
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &key) == FAILURE) {
+               return;
+       }
+
+       zend_weakmap_unset_dimension(Z_OBJ_P(ZEND_THIS), key);
+}
+
+ZEND_METHOD(WeakMap, count)
+{
+       if (zend_parse_parameters_none() == FAILURE) {
+               return;
+       }
+
+       zend_long count;
+       zend_weakmap_count_elements(Z_OBJ_P(ZEND_THIS), &count);
+       RETURN_LONG(count);
+}
+
+static const zend_function_entry zend_weakmap_methods[] = {
+       ZEND_ME(WeakMap, offsetGet, arginfo_class_WeakMap_offsetGet, ZEND_ACC_PUBLIC)
+       ZEND_ME(WeakMap, offsetSet, arginfo_class_WeakMap_offsetSet, ZEND_ACC_PUBLIC)
+       ZEND_ME(WeakMap, offsetExists, arginfo_class_WeakMap_offsetExists, ZEND_ACC_PUBLIC)
+       ZEND_ME(WeakMap, offsetUnset, arginfo_class_WeakMap_offsetUnset, ZEND_ACC_PUBLIC)
+       ZEND_ME(WeakMap, count, arginfo_class_WeakMap_count, ZEND_ACC_PUBLIC)
+       ZEND_FE_END
+};
+
 void zend_register_weakref_ce(void) /* {{{ */
 {
        zend_class_entry ce;
@@ -199,6 +651,36 @@ void zend_register_weakref_ce(void) /* {{{ */
        zend_weakref_handlers.unset_property = zend_weakref_no_unset;
        zend_weakref_handlers.get_property_ptr_ptr = zend_weakref_no_read_ptr;
        zend_weakref_handlers.clone_obj = NULL;
+
+       INIT_CLASS_ENTRY(ce, "WeakMap", zend_weakmap_methods);
+       zend_ce_weakmap = zend_register_internal_class(&ce);
+       zend_ce_weakmap->ce_flags |= ZEND_ACC_FINAL;
+
+       zend_ce_weakmap->create_object = zend_weakmap_create_object;
+       zend_ce_weakmap->get_iterator = zend_weakmap_get_iterator;
+       zend_ce_weakmap->serialize = zend_class_serialize_deny;
+       zend_ce_weakmap->unserialize = zend_class_unserialize_deny;
+
+       /* Must happen after get_iterator is assigned. */
+       zend_class_implements(
+               zend_ce_weakmap, 3, zend_ce_arrayaccess, zend_ce_countable, zend_ce_traversable);
+
+       memcpy(&zend_weakmap_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+       zend_weakmap_handlers.offset = XtOffsetOf(zend_weakmap, std);
+       zend_weakmap_handlers.free_obj = zend_weakmap_free_obj;
+       zend_weakmap_handlers.read_dimension = zend_weakmap_read_dimension;
+       zend_weakmap_handlers.write_dimension = zend_weakmap_write_dimension;
+       zend_weakmap_handlers.has_dimension = zend_weakmap_has_dimension;
+       zend_weakmap_handlers.unset_dimension = zend_weakmap_unset_dimension;
+       zend_weakmap_handlers.count_elements = zend_weakmap_count_elements;
+       zend_weakmap_handlers.get_properties_for = zend_weakmap_get_properties_for;
+       zend_weakmap_handlers.get_gc = zend_weakmap_get_gc;
+       zend_weakmap_handlers.clone_obj = zend_weakmap_clone_obj;
+       zend_weakmap_handlers.read_property = zend_weakref_no_read;
+       zend_weakmap_handlers.write_property = zend_weakref_no_write;
+       zend_weakmap_handlers.has_property = zend_weakref_no_isset;
+       zend_weakmap_handlers.unset_property = zend_weakref_no_unset;
+       zend_weakmap_handlers.get_property_ptr_ptr = zend_weakref_no_read_ptr;
 }
 /* }}} */
 

diff --git a/Zend/zend_weakrefs.stub.php b/Zend/zend_weakrefs.stub.php
index 52ae81c7b8a83e189c47e1501e6f7a0d17592f5e..aada11bc79e02e1dc249ddeb0cd066dd150037ef 100644 (file)
--- a/Zend/zend_weakrefs.stub.php
+++ b/Zend/zend_weakrefs.stub.php
@@ -7,3 +7,27 @@ final class WeakReference {
 
     public function get(): ?object;
 }
+
+final class WeakMap implements ArrayAccess, Countable, Traversable {
+    //public function __construct();
+
+    /**
+     * @param object $object
+     * @return mixed
+     */
+    public function offsetGet($object);
+
+    /**
+     * @param object $object
+     * @param mixed $value
+     */
+    public function offsetSet($object, $value): void;
+
+    /** @param object $object */
+    public function offsetExists($object): bool;
+
+    /** @param object $object */
+    public function offsetUnset($object): void;
+
+    public function count(): int;
+}

diff --git a/Zend/zend_weakrefs_arginfo.h b/Zend/zend_weakrefs_arginfo.h
index abcd0c8d99a5817d3d56ed5f2132a3948337011f..b10c1b63b5de3cbebad22d3fe3967e718d2b066d 100644 (file)
--- a/Zend/zend_weakrefs_arginfo.h
+++ b/Zend/zend_weakrefs_arginfo.h
@@ -8,3 +8,23 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakReference_get, 0, 0, IS_OBJECT, 1)
 ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_WeakMap_offsetGet, 0, 0, 1)
+       ZEND_ARG_INFO(0, object)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakMap_offsetSet, 0, 2, IS_VOID, 0)
+       ZEND_ARG_INFO(0, object)
+       ZEND_ARG_INFO(0, value)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakMap_offsetExists, 0, 1, _IS_BOOL, 0)
+       ZEND_ARG_INFO(0, object)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakMap_offsetUnset, 0, 1, IS_VOID, 0)
+       ZEND_ARG_INFO(0, object)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakMap_count, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()