refactor: change zend_is_true to return bool (#14301)

morrisonlevi · web-flow · commit c461b6006056 · 2024-05-24T15:16:36.000-06:00
Previously this returned `int`. Many functions actually take advantage
of the fact this returns exactly 0 or 1. For instance,
`main/streams/xp_socket.c` does:

    sockopts |= STREAM_SOCKOP_IPV6_V6ONLY_ENABLED * zend_is_true(tmpzval);

And `Zend/zend_compile.c` does:

    child = &amp;ast-&gt;child[2 - zend_is_true(zend_ast_get_zval(ast-&gt;child[0]))];

I changed a few places trivially from `int` to `bool`, but there are
still many places such as the object handlers which return `int` that
should eventually be `bool`.
diff --git a/UPGRADING.INTERNALS b/UPGRADING.INTERNALS
@@ -86,6 +86,8 @@ PHP 8.4 INTERNALS UPGRADE NOTES
   for internal functions. If you need a cache slot for both internal and user
   functions, you may obtain a slot for each through the corresponding function.
 
+* zend_is_true now returns bool rather than int. Note that on PHP 8 this has
+  always returned 0 or 1, so conversion should be trivial.
 
 ========================
 2. Build system changes
diff --git a/Zend/Optimizer/pass1.c b/Zend/Optimizer/pass1.c
@@ -309,7 +309,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 		case ZEND_JMPZ:
 		case ZEND_JMPNZ:
 			if (opline->op1_type == IS_CONST) {
-				int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
+				bool should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
 
 				if (opline->opcode == ZEND_JMPZ) {
 					should_jmp = !should_jmp;
diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
@@ -1057,11 +1057,12 @@ ZEND_API void zend_std_write_dimension(zend_object *object, zval *offset, zval *
 }
 /* }}} */
 
+// todo: make zend_std_has_dimension return bool as well
 ZEND_API int zend_std_has_dimension(zend_object *object, zval *offset, int check_empty) /* {{{ */
 {
 	zend_class_entry *ce = object->ce;
 	zval retval, tmp_offset;
-	int result;
+	bool result;
 
 	zend_class_arrayaccess_funcs *funcs = ce->arrayaccess_funcs_ptr;
 	if (EXPECTED(funcs)) {
@@ -1081,6 +1082,7 @@ ZEND_API int zend_std_has_dimension(zend_object *object, zval *offset, int check
 	    zend_bad_array_access(ce);
 		return 0;
 	}
+
 	return result;
 }
 /* }}} */
@@ -1810,9 +1812,10 @@ ZEND_API int zend_objects_not_comparable(zval *o1, zval *o2)
 	return ZEND_UNCOMPARABLE;
 }
 
+// todo: make zend_std_has_property return bool as well
 ZEND_API int zend_std_has_property(zend_object *zobj, zend_string *name, int has_set_exists, void **cache_slot) /* {{{ */
 {
-	int result;
+	bool result;
 	zval *value = NULL;
 	uintptr_t property_offset;
 	const zend_property_info *prop_info = NULL;
@@ -1826,7 +1829,7 @@ ZEND_API int zend_std_has_property(zend_object *zobj, zend_string *name, int has
 		}
 		if (UNEXPECTED(Z_PROP_FLAG_P(value) & IS_PROP_UNINIT)) {
 			/* Skip __isset() for uninitialized typed properties */
-			result = 0;
+			result = false;
 			goto exit;
 		}
 	} else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {
@@ -1862,17 +1865,17 @@ ZEND_API int zend_std_has_property(zend_object *zobj, zend_string *name, int has
 					result = (Z_TYPE_P(value) != IS_NULL);
 				} else {
 					ZEND_ASSERT(has_set_exists == ZEND_PROPERTY_EXISTS);
-					result = 1;
+					result = true;
 				}
 				goto exit;
 			}
 		}
 	} else if (UNEXPECTED(EG(exception))) {
-		result = 0;
+		result = false;
 		goto exit;
 	}
 
-	result = 0;
+	result = false;
 	if ((has_set_exists != ZEND_PROPERTY_EXISTS) && zobj->ce->__isset) {
 		uint32_t *guard = zend_get_property_guard(zobj, name);
 
@@ -1893,7 +1896,7 @@ ZEND_API int zend_std_has_property(zend_object *zobj, zend_string *name, int has
 					result = i_zend_is_true(&rv);
 					zval_ptr_dtor(&rv);
 				} else {
-					result = 0;
+					result = false;
 				}
 			}
 			(*guard) &= ~IN_ISSET;
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
@@ -2818,9 +2818,9 @@ ZEND_API zend_result ZEND_FASTCALL decrement_function(zval *op1) /* {{{ */
 }
 /* }}} */
 
-ZEND_API int ZEND_FASTCALL zend_is_true(const zval *op) /* {{{ */
+ZEND_API bool ZEND_FASTCALL zend_is_true(const zval *op) /* {{{ */
 {
-	return (int) i_zend_is_true(op);
+	return i_zend_is_true(op);
 }
 /* }}} */
 
diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
@@ -372,7 +372,7 @@ static zend_always_inline bool try_convert_to_string(zval *op) {
 #define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op)); }
 
 
-ZEND_API int ZEND_FASTCALL zend_is_true(const zval *op);
+ZEND_API bool ZEND_FASTCALL zend_is_true(const zval *op);
 ZEND_API bool ZEND_FASTCALL zend_object_is_true(const zval *op);
 
 #define zval_is_true(op) \
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -7313,8 +7313,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|
 {
 	USE_OPLINE
 	zval *value;
-	/* Should be bool result? as below got: result = (opline->extended_value & ZEND_ISEMPTY) */
-	int result;
+	bool result;
 	zval *varname;
 	zend_string *name, *tmp_name;
 	HashTable *target_symbol_table;
@@ -7351,7 +7350,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|
 		}
 	}
 
-	ZEND_VM_SMART_BRANCH(result, 1);
+	ZEND_VM_SMART_BRANCH(result, true);
 }
 
 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
diff --git a/Zend/zend_weakrefs.c b/Zend/zend_weakrefs.c
@@ -405,6 +405,7 @@ static void zend_weakmap_write_dimension(zend_object *object, zval *offset, zval
 	zend_hash_index_add_new(&wm->ht, obj_key, value);
 }
 
+// todo: make zend_weakmap_has_dimension return bool as well
 /* int return and check_empty due to Object Handler API */
 static int zend_weakmap_has_dimension(zend_object *object, zval *offset, int check_empty)
 {
diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c
@@ -404,12 +404,13 @@ zval *dom_write_property(zend_object *object, zend_string *name, zval *value, vo
 	return zend_std_write_property(object, name, value, cache_slot);
 }
 
+// todo: make dom_property_exists return bool as well
 /* {{{ dom_property_exists */
 static int dom_property_exists(zend_object *object, zend_string *name, int check_empty, void **cache_slot)
 {
 	dom_object *obj = php_dom_obj_from_obj(object);
 	dom_prop_handler *hnd = NULL;
-	int retval = 0;
+	bool retval = false;
 
 	if (obj->prop_handler != NULL) {
 		hnd = zend_hash_find_ptr(obj->prop_handler, name);
@@ -418,7 +419,7 @@ static int dom_property_exists(zend_object *object, zend_string *name, int check
 		zval tmp;
 
 		if (check_empty == 2) {
-			retval = 1;
+			retval = true;
 		} else if (hnd->read_func(obj, &tmp) == SUCCESS) {
 			if (check_empty == 1) {
 				retval = zend_is_true(&tmp);
@@ -1441,7 +1442,7 @@ zend_object *dom_xpath_objects_new(zend_class_entry *class_type)
 	dom_xpath_object *intern = zend_object_alloc(sizeof(dom_xpath_object), class_type);
 
 	php_dom_xpath_callbacks_ctor(&intern->xpath_callbacks);
-	intern->register_node_ns = 1;
+	intern->register_node_ns = true;
 
 	intern->dom.prop_handler = &dom_xpath_prop_handlers;
 
diff --git a/ext/dom/php_dom.h b/ext/dom/php_dom.h
@@ -66,7 +66,7 @@ extern zend_module_entry dom_module_entry;
 
 typedef struct _dom_xpath_object {
 	php_dom_xpath_callbacks xpath_callbacks;
-	int register_node_ns;
+	bool register_node_ns;
 	dom_object dom;
 } dom_xpath_object;
 
diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c
@@ -2344,6 +2344,7 @@ static void row_dim_write(zend_object *object, zval *member, zval *value)
 	}
 }
 
+// todo: make row_prop_exists return bool as well
 static int row_prop_exists(zend_object *object, zend_string *name, int check_empty, void **cache_slot)
 {
 	pdo_row_t *row = (pdo_row_t *)object;
@@ -2363,11 +2364,14 @@ static int row_prop_exists(zend_object *object, zend_string *name, int check_emp
 		return false;
 	}
 	ZEND_ASSERT(retval == &tmp_val);
-	int res = check_empty ? i_zend_is_true(retval) : Z_TYPE(tmp_val) != IS_NULL;
+	bool res = check_empty ? i_zend_is_true(retval) : Z_TYPE(tmp_val) != IS_NULL;
 	zval_ptr_dtor_nogc(retval);
+
 	return res;
 }
 
+
+// todo: make row_dim_exists return bool as well
 static int row_dim_exists(zend_object *object, zval *offset, int check_empty)
 {
 	if (Z_TYPE_P(offset) == IS_LONG) {
@@ -2386,7 +2390,7 @@ static int row_dim_exists(zend_object *object, zval *offset, int check_empty)
 			return false;
 		}
 		ZEND_ASSERT(retval == &tmp_val);
-		int res = check_empty ? i_zend_is_true(retval) : Z_TYPE(tmp_val) != IS_NULL;
+		bool res = check_empty ? i_zend_is_true(retval) : Z_TYPE(tmp_val) != IS_NULL;
 		zval_ptr_dtor_nogc(retval);
 		return res;
 	} else {
diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c
@@ -851,7 +851,7 @@ PHP_METHOD(DirectoryIterator, seek)
 	}
 
 	while (intern->u.dir.index < pos) {
-		bool valid = 0;
+		bool valid = false;
 		zend_call_method_with_0_params(Z_OBJ_P(ZEND_THIS), Z_OBJCE_P(ZEND_THIS), &intern->u.dir.func_valid, "valid", &retval);
 		valid = zend_is_true(&retval);
 		zval_ptr_dtor(&retval);
diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
@@ -263,7 +263,6 @@ static void spl_recursive_it_move_forward_ex(spl_recursive_it_object *object, zv
 	zend_class_entry          *ce;
 	zval                      retval, child;
 	zend_object_iterator      *sub_iter;
-	int                       has_children;
 
 	SPL_FETCH_SUB_ITERATOR(iterator, object);
 
@@ -308,7 +307,7 @@ static void spl_recursive_it_move_forward_ex(spl_recursive_it_object *object, zv
 					}
 				}
 				if (Z_TYPE(retval) != IS_UNDEF) {
-					has_children = zend_is_true(&retval);
+					bool has_children = zend_is_true(&retval);
 					zval_ptr_dtor(&retval);
 					if (has_children) {
 						if (object->max_depth == -1 || object->max_depth > object->level) {
diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c
@@ -440,6 +440,7 @@ PHP_METHOD(SplObjectStorage, attach)
 	spl_object_storage_attach(intern, obj, inf);
 } /* }}} */
 
+// todo: make spl_object_storage_has_dimension return bool as well
 static int spl_object_storage_has_dimension(zend_object *object, zval *offset, int check_empty)
 {
 	spl_SplObjectStorage *intern = spl_object_storage_from_obj(object);
diff --git a/ext/standard/array.c b/ext/standard/array.c
@@ -6548,7 +6548,7 @@ PHP_FUNCTION(array_filter)
 			fci.params = args;
 
 			if (zend_call_function(&fci, &fci_cache) == SUCCESS) {
-				int retval_true;
+				bool retval_true;
 
 				zval_ptr_dtor(&args[0]);
 				if (use_type == ARRAY_FILTER_USE_BOTH) {
diff --git a/ext/standard/filters.c b/ext/standard/filters.c
@@ -1113,20 +1113,20 @@ static php_conv_err_t php_conv_get_ulong_prop_ex(const HashTable *ht, zend_ulong
 	}
 }
 
-static php_conv_err_t php_conv_get_bool_prop_ex(const HashTable *ht, int *pretval, char *field_name, size_t field_name_len)
+static php_conv_err_t php_conv_get_bool_prop_ex(const HashTable *ht, bool *pretval, char *field_name, size_t field_name_len)
 {
 	zval *tmpval = zend_hash_str_find((HashTable *)ht, field_name, field_name_len-1);
 	if (tmpval != NULL) {
 		*pretval = zend_is_true(tmpval);
 		return PHP_CONV_ERR_SUCCESS;
 	} else {
-		*pretval = 0;
+		*pretval = false;
 		return PHP_CONV_ERR_NOT_FOUND;
 	}
 }
 
 /* XXX this might need an additional fix so it uses size_t, whereby unsigned is quite big so leaving as is for now */
-static int php_conv_get_uint_prop_ex(const HashTable *ht, unsigned int *pretval, char *field_name, size_t field_name_len)
+static php_conv_err_t php_conv_get_uint_prop_ex(const HashTable *ht, unsigned int *pretval, char *field_name, size_t field_name_len)
 {
 	zend_ulong l;
 	php_conv_err_t err;
@@ -1206,8 +1206,8 @@ static php_conv *php_conv_open(int conv_mode, const HashTable *options, int pers
 			int opts = 0;
 
 			if (options != NULL) {
-				int opt_binary = 0;
-				int opt_force_encode_first = 0;
+				bool opt_binary = false;
+				bool opt_force_encode_first = false;
 
 				GET_STR_PROP(options, lbchars, lbchars_len, "line-break-chars", 0);
 				GET_UINT_PROP(options, line_len, "line-length");
diff --git a/ext/standard/http_fopen_wrapper.c b/ext/standard/http_fopen_wrapper.c
@@ -136,7 +136,7 @@ static php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 	zend_string *transport_string;
 	zend_string *errstr = NULL;
 	int have_header = 0;
-	bool request_fulluri = 0, ignore_errors = 0;
+	bool request_fulluri = false, ignore_errors = false;
 	struct timeval timeout;
 	char *user_headers = NULL;
 	int header_init = ((flags & HTTP_WRAPPER_HEADER_INIT) != 0);
@@ -171,7 +171,7 @@ static php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 			return php_stream_open_wrapper_ex(path, mode, REPORT_ERRORS, NULL, context);
 		}
 		/* Called from a non-http wrapper with http proxying requested (i.e. ftp) */
-		request_fulluri = 1;
+		request_fulluri = true;
 		use_ssl = 0;
 		use_proxy = 1;
 		transport_string = zend_string_copy(Z_STR_P(tmpzval));
@@ -801,7 +801,7 @@ static php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 
 				/* create filter to decode response body */
 				if (!(options & STREAM_ONLY_GET_HEADERS)) {
-					zend_long decode = 1;
+					bool decode = true;
 
 					if (context && (tmpzval = php_stream_context_get_option(context, "http", "auto_decode")) != NULL) {
 						decode = zend_is_true(tmpzval);
diff --git a/ext/xsl/xsltprocessor.c b/ext/xsl/xsltprocessor.c
@@ -197,7 +197,7 @@ PHP_METHOD(XSLTProcessor, importStylesheet)
 	zval *id, *docp = NULL;
 	xmlDoc *doc = NULL, *newdoc = NULL;
 	xsltStylesheetPtr sheetp;
-	int clone_docu = 0;
+	bool clone_docu = false;
 	xmlNode *nodep = NULL;
 	zval *cloneDocu, rv;
 	zend_string *member;
@@ -257,7 +257,7 @@ PHP_METHOD(XSLTProcessor, importStylesheet)
 	cloneDocu = zend_std_read_property(Z_OBJ_P(id), member, BP_VAR_R, NULL, &rv);
 	clone_docu = zend_is_true(cloneDocu);
 	zend_string_release_ex(member, 0);
-	if (clone_docu == 0) {
+	if (!clone_docu) {
 		/* Check if the stylesheet is using xsl:key, if yes, we have to clone the document _always_ before a transformation.
 		 * xsl:key elements may only occur at the top level. Furthermore, all elements at the top level must be in a
 		 * namespace (if not, then the stylesheet is not well-formed and this function will have returned false earlier). */
diff --git a/ext/zip/php_zip.c b/ext/zip/php_zip.c
diff --git a/sapi/phpdbg/phpdbg.c b/sapi/phpdbg/phpdbg.c

Original file line number	Diff line number	Diff line change
`@@ -1057,11 +1057,12 @@ ZEND_API void zend_std_write_dimension(zend_object object, zval offset, zval *`
`1057`	`1057`	`}`
`1058`	`1058`	`/* }}} */`
`1059`	`1059`
	`1060`	`+// todo: make zend_std_has_dimension return bool as well`
`1060`	`1061`	`ZEND_API int zend_std_has_dimension(zend_object object, zval offset, int check_empty) /* {{{ */`
`1061`	`1062`	`{`
`1062`	`1063`	`zend_class_entry *ce = object->ce;`
`1063`	`1064`	`zval retval, tmp_offset;`
`1064`		`- int result;`
	`1065`	`+ bool result;`
`1065`	`1066`
`1066`	`1067`	`zend_class_arrayaccess_funcs *funcs = ce->arrayaccess_funcs_ptr;`
`1067`	`1068`	`if (EXPECTED(funcs)) {`
`@@ -1081,6 +1082,7 @@ ZEND_API int zend_std_has_dimension(zend_object object, zval offset, int check`
`1081`	`1082`	`zend_bad_array_access(ce);`
`1082`	`1083`	`return 0;`
`1083`	`1084`	`}`
	`1085`	`+`
`1084`	`1086`	`return result;`
`1085`	`1087`	`}`
`1086`	`1088`	`/* }}} */`
`@@ -1810,9 +1812,10 @@ ZEND_API int zend_objects_not_comparable(zval o1, zval o2)`
`1810`	`1812`	`return ZEND_UNCOMPARABLE;`
`1811`	`1813`	`}`
`1812`	`1814`
	`1815`	`+// todo: make zend_std_has_property return bool as well`
`1813`	`1816`	`ZEND_API int zend_std_has_property(zend_object zobj, zend_string name, int has_set_exists, void *cache_slot) / {{{ */`
`1814`	`1817`	`{`
`1815`		`- int result;`
	`1818`	`+ bool result;`
`1816`	`1819`	`zval *value = NULL;`
`1817`	`1820`	`uintptr_t property_offset;`
`1818`	`1821`	`const zend_property_info *prop_info = NULL;`
`@@ -1826,7 +1829,7 @@ ZEND_API int zend_std_has_property(zend_object zobj, zend_string name, int has`
`1826`	`1829`	`}`
`1827`	`1830`	`if (UNEXPECTED(Z_PROP_FLAG_P(value) & IS_PROP_UNINIT)) {`
`1828`	`1831`	`/* Skip __isset() for uninitialized typed properties */`
`1829`		`- result = 0;`
	`1832`	`+ result = false;`
`1830`	`1833`	`goto exit;`
`1831`	`1834`	`}`
`1832`	`1835`	`} else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {`
`@@ -1862,17 +1865,17 @@ ZEND_API int zend_std_has_property(zend_object zobj, zend_string name, int has`
`1862`	`1865`	`result = (Z_TYPE_P(value) != IS_NULL);`
`1863`	`1866`	`} else {`
`1864`	`1867`	`ZEND_ASSERT(has_set_exists == ZEND_PROPERTY_EXISTS);`
`1865`		`- result = 1;`
	`1868`	`+ result = true;`
`1866`	`1869`	`}`
`1867`	`1870`	`goto exit;`
`1868`	`1871`	`}`
`1869`	`1872`	`}`
`1870`	`1873`	`} else if (UNEXPECTED(EG(exception))) {`
`1871`		`- result = 0;`
	`1874`	`+ result = false;`
`1872`	`1875`	`goto exit;`
`1873`	`1876`	`}`
`1874`	`1877`
`1875`		`- result = 0;`
	`1878`	`+ result = false;`
`1876`	`1879`	`if ((has_set_exists != ZEND_PROPERTY_EXISTS) && zobj->ce->__isset) {`
`1877`	`1880`	`uint32_t *guard = zend_get_property_guard(zobj, name);`
`1878`	`1881`
`@@ -1893,7 +1896,7 @@ ZEND_API int zend_std_has_property(zend_object zobj, zend_string name, int has`
`1893`	`1896`	`result = i_zend_is_true(&rv);`
`1894`	`1897`	`zval_ptr_dtor(&rv);`
`1895`	`1898`	`} else {`
`1896`		`- result = 0;`
	`1899`	`+ result = false;`
`1897`	`1900`	`}`
`1898`	`1901`	`}`
`1899`	`1902`	`(*guard) &= ~IN_ISSET;`
Original file line number	Diff line number	Diff line change
`@@ -2818,9 +2818,9 @@ ZEND_API zend_result ZEND_FASTCALL decrement_function(zval op1) / {{{ */`
`2818`	`2818`	`}`
`2819`	`2819`	`/* }}} */`
`2820`	`2820`
`2821`		`-ZEND_API int ZEND_FASTCALL zend_is_true(const zval op) / {{{ */`
	`2821`	`+ZEND_API bool ZEND_FASTCALL zend_is_true(const zval op) / {{{ */`
`2822`	`2822`	`{`
`2823`		`- return (int) i_zend_is_true(op);`
	`2823`	`+ return i_zend_is_true(op);`
`2824`	`2824`	`}`
`2825`	`2825`	`/* }}} */`
`2826`	`2826`
Original file line number	Diff line number	Diff line change
`@@ -7313,8 +7313,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST\|TMPVAR\|CV, UNUSED, VAR_FETCH\|`
`7313`	`7313`	`{`
`7314`	`7314`	`USE_OPLINE`
`7315`	`7315`	`zval *value;`
`7316`		`- /* Should be bool result? as below got: result = (opline->extended_value & ZEND_ISEMPTY) */`
`7317`		`- int result;`
	`7316`	`+ bool result;`
`7318`	`7317`	`zval *varname;`
`7319`	`7318`	`zend_string name, tmp_name;`
`7320`	`7319`	`HashTable *target_symbol_table;`
`@@ -7351,7 +7350,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST\|TMPVAR\|CV, UNUSED, VAR_FETCH\|`
`7351`	`7350`	`}`
`7352`	`7351`	`}`
`7353`	`7352`
`7354`		`- ZEND_VM_SMART_BRANCH(result, 1);`
	`7353`	`+ ZEND_VM_SMART_BRANCH(result, true);`
`7355`	`7354`	`}`
`7356`	`7355`
`7357`	`7356`	`/* No specialization for op_types (CONST\|TMPVAR\|CV, UNUSED\|CLASS_FETCH\|CONST\|VAR) */`
Original file line number	Diff line number	Diff line change
`@@ -405,6 +405,7 @@ static void zend_weakmap_write_dimension(zend_object object, zval offset, zval`
`405`	`405`	`zend_hash_index_add_new(&wm->ht, obj_key, value);`
`406`	`406`	`}`
`407`	`407`
	`408`	`+// todo: make zend_weakmap_has_dimension return bool as well`
`408`	`409`	`/* int return and check_empty due to Object Handler API */`
`409`	`410`	`static int zend_weakmap_has_dimension(zend_object object, zval offset, int check_empty)`
`410`	`411`	`{`