Introduce InternalIterator

Author: nikic

Zend/tests/bug48667_1.phpt

@@ -7,4 +7,4 @@ abstract class A implements Iterator, IteratorAggregate { }
 
 ?>
 --EXPECTF--
-Fatal error: Class A cannot implement both IteratorAggregate and Iterator at the same time in %s on line %d
+Fatal error: Class A cannot implement both Iterator and IteratorAggregate at the same time in %s on line %d

Zend/zend_inheritance.c

@@ -135,13 +135,6 @@ static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */
 	ce->create_object = parent->create_object;
 
 	/* Inherit special functions if needed */
-	if (EXPECTED(!ce->get_iterator)) {
-		ce->get_iterator = parent->get_iterator;
-	}
-	if (parent->iterator_funcs_ptr) {
-		/* Must be initialized through iface->interface_gets_implemented() */
-		ZEND_ASSERT(ce->iterator_funcs_ptr);
-	}
 	if (EXPECTED(!ce->__get)) {
 		ce->__get = parent->__get;
 	}
@@ -1182,19 +1175,6 @@ ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *par
 	ce->parent = parent_ce;
 	ce->ce_flags |= ZEND_ACC_RESOLVED_PARENT;
 
-	/* Inherit interfaces */
-	if (parent_ce->num_interfaces) {
-		if (!ce->num_interfaces) {
-			zend_do_inherit_interfaces(ce, parent_ce);
-		} else {
-			uint32_t i;
-
-			for (i = 0; i < parent_ce->num_interfaces; i++) {
-				do_implement_interface(ce, parent_ce->interfaces[i]);
-			}
-		}
-	}
-
 	/* Inherit properties */
 	if (parent_ce->default_properties_count) {
 		zval *src, *dst, *end;
@@ -1372,6 +1352,14 @@ ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *par
 		}
 	}
 
+	/* Inherit interfaces */
+	if (parent_ce->num_interfaces) {
+		/* If ce has interfaces itself, zend_do_implement_interfaces() will handle this later. */
+		if (!ce->num_interfaces) {
+			zend_do_inherit_interfaces(ce, parent_ce);
+		}
+	}
+
 	do_inherit_parent_constructor(ce);
 
 	if (ce->type == ZEND_INTERNAL_CLASS) {
@@ -1530,8 +1518,12 @@ static void zend_do_implement_interfaces(zend_class_entry *ce, zend_class_entry
 	ce->interfaces = interfaces;
 	ce->ce_flags |= ZEND_ACC_RESOLVED_INTERFACES;
 
-	i = num_parent_interfaces;
-	for (; i < ce->num_interfaces; i++) {
+	for (i = 0; i < num_parent_interfaces; i++) {
+		do_implement_interface(ce, ce->interfaces[i]);
+	}
+	/* Note that new interfaces can be added during this loop due to interface inheritance.
+	 * Use num_interfaces rather than ce->num_interfaces to not re-process the new ones. */
+	for (; i < num_interfaces; i++) {
 		do_interface_implementation(ce, ce->interfaces[i]);
 	}
 }

Zend/zend_interfaces.c

@@ -28,6 +28,9 @@ ZEND_API zend_class_entry *zend_ce_iterator;
 ZEND_API zend_class_entry *zend_ce_arrayaccess;
 ZEND_API zend_class_entry *zend_ce_serializable;
 ZEND_API zend_class_entry *zend_ce_countable;
+ZEND_API zend_class_entry *zend_ce_internal_iterator;
+
+static zend_object_handlers zend_internal_iterator_handlers;
 
 /* {{{ zend_call_method
  Only returns the returned zval if retval_ptr != NULL */
@@ -286,12 +289,9 @@ ZEND_API zend_object_iterator *zend_user_it_get_new_iterator(zend_class_entry *c
 /* {{{ zend_implement_traversable */
 static int zend_implement_traversable(zend_class_entry *interface, zend_class_entry *class_type)
 {
-	/* check that class_type is traversable at c-level or implements at least one of 'aggregate' and 'Iterator' */
+	/* Check that class_type implements at least one of 'IteratorAggregate' or 'Iterator' */
 	uint32_t i;
 
-	if (class_type->get_iterator || (class_type->parent && class_type->parent->get_iterator)) {
-		return SUCCESS;
-	}
 	if (class_type->num_interfaces) {
 		ZEND_ASSERT(class_type->ce_flags & ZEND_ACC_RESOLVED_INTERFACES);
 		for (i = 0; i < class_type->num_interfaces; i++) {
@@ -312,59 +312,38 @@ static int zend_implement_traversable(zend_class_entry *interface, zend_class_en
 /* {{{ zend_implement_aggregate */
 static int zend_implement_aggregate(zend_class_entry *interface, zend_class_entry *class_type)
 {
-	uint32_t i;
-	int t = -1;
-	zend_class_iterator_funcs *funcs_ptr;
+	if (zend_class_implements_interface(class_type, zend_ce_iterator)) {
+		zend_error_noreturn(E_ERROR,
+			"Class %s cannot implement both Iterator and IteratorAggregate at the same time",
+			ZSTR_VAL(class_type->name));
+	}
 
 	if (class_type->get_iterator) {
-		if (class_type->type == ZEND_INTERNAL_CLASS) {
-			/* inheritance ensures the class has necessary userland methods */
-			return SUCCESS;
-		} else if (class_type->get_iterator != zend_user_it_get_new_iterator) {
-			/* c-level get_iterator cannot be changed (exception being only Traversable is implemented) */
-			if (class_type->num_interfaces) {
-				ZEND_ASSERT(class_type->ce_flags & ZEND_ACC_RESOLVED_INTERFACES);
-				for (i = 0; i < class_type->num_interfaces; i++) {
-					if (class_type->interfaces[i] == zend_ce_iterator) {
-						zend_error_noreturn(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
-									ZSTR_VAL(class_type->name),
-									ZSTR_VAL(interface->name),
-									ZSTR_VAL(zend_ce_iterator->name));
-						return FAILURE;
-					}
-					if (class_type->interfaces[i] == zend_ce_traversable) {
-						t = i;
-					}
-				}
-			}
-			if (t == -1) {
-				return FAILURE;
-			}
-		}
+		/* An internal class with a custom get_iterator implementation. */
+		ZEND_ASSERT(class_type->type == ZEND_INTERNAL_CLASS);
+		return SUCCESS;
 	}
-	if (class_type->parent
-	 && (class_type->parent->ce_flags & ZEND_ACC_REUSE_GET_ITERATOR)) {
+
+	zend_function *zf = zend_hash_str_find_ptr(
+		&class_type->function_table, "getiterator", sizeof("getiterator") - 1);
+	if (class_type->parent && class_type->parent->get_iterator != zend_user_it_get_new_iterator
+			&& zf->common.scope != class_type) {
+		/* We have a custom get_iterator on the parent class, and the getIterator() method
+		 * has not been overridden in this class: Inherit the parent get_iterator.
+		 * Otherwise fall back to a normal call of the overridden getIterator(). */
 		class_type->get_iterator = class_type->parent->get_iterator;
-		class_type->ce_flags |= ZEND_ACC_REUSE_GET_ITERATOR;
-	} else {
-		class_type->get_iterator = zend_user_it_get_new_iterator;
-	}
-	funcs_ptr = class_type->iterator_funcs_ptr;
-	if (class_type->type == ZEND_INTERNAL_CLASS) {
-		if (!funcs_ptr) {
-			funcs_ptr = calloc(1, sizeof(zend_class_iterator_funcs));
-			class_type->iterator_funcs_ptr = funcs_ptr;
-		}
-		funcs_ptr->zf_new_iterator = zend_hash_str_find_ptr(&class_type->function_table, "getiterator", sizeof("getiterator") - 1);
-	} else {
-		if (!funcs_ptr) {
-			funcs_ptr = zend_arena_alloc(&CG(arena), sizeof(zend_class_iterator_funcs));
-			class_type->iterator_funcs_ptr = funcs_ptr;
-			memset(funcs_ptr, 0, sizeof(zend_class_iterator_funcs));
-		} else {
-			funcs_ptr->zf_new_iterator = NULL;
-		}
+		return SUCCESS;
 	}
+
+	ZEND_ASSERT(!class_type->iterator_funcs_ptr && "Iterator funcs already set?");
+	zend_class_iterator_funcs *funcs_ptr = class_type->type == ZEND_INTERNAL_CLASS
+		? pemalloc(sizeof(zend_class_iterator_funcs), 1)
+		: zend_arena_alloc(&CG(arena), sizeof(zend_class_iterator_funcs));
+	class_type->get_iterator = zend_user_it_get_new_iterator;
+	class_type->iterator_funcs_ptr = funcs_ptr;
+	memset(funcs_ptr, 0, sizeof(zend_class_iterator_funcs));
+	funcs_ptr->zf_new_iterator = zf;
+
 	return SUCCESS;
 }
 /* }}} */
@@ -381,12 +360,9 @@ static int zend_implement_iterator(zend_class_entry *interface, zend_class_entry
 		} else {
 			/* c-level get_iterator cannot be changed */
 			if (class_type->get_iterator == zend_user_it_get_new_iterator) {
-				zend_error_noreturn(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
-							ZSTR_VAL(class_type->name),
-							ZSTR_VAL(interface->name),
-							ZSTR_VAL(zend_ce_aggregate->name));
+				zend_error_noreturn(E_ERROR, "Class %s cannot implement both Iterator and IteratorAggregate at the same time",
+							ZSTR_VAL(class_type->name));
 			}
-			return FAILURE;
 		}
 	}
 	if (class_type->parent
@@ -532,6 +508,157 @@ static int zend_implement_countable(zend_class_entry *interface, zend_class_entr
 }
 /* }}}*/
 
+typedef struct {
+	zend_object std;
+	zend_object_iterator *iter;
+	zend_bool rewind_called;
+} zend_internal_iterator;
+
+static zend_object *zend_internal_iterator_create(zend_class_entry *ce) {
+	zend_internal_iterator *intern = emalloc(sizeof(zend_internal_iterator));
+	zend_object_std_init(&intern->std, ce);
+	intern->std.handlers = &zend_internal_iterator_handlers;
+	intern->iter = NULL;
+	intern->rewind_called = 0;
+	return &intern->std;
+}
+
+ZEND_API int zend_create_internal_iterator_zval(zval *return_value, zval *obj) {
+	zend_class_entry *ce = Z_OBJCE_P(obj);
+	ZEND_ASSERT(ce->get_iterator != zend_user_it_get_new_iterator);
+	zend_object_iterator *iter = ce->get_iterator(ce, obj, /* by_ref */ 0);
+	if (!iter) {
+		return FAILURE;
+	}
+
+	zend_internal_iterator *intern =
+		(zend_internal_iterator *) zend_internal_iterator_create(zend_ce_internal_iterator);
+	intern->iter = iter;
+	ZVAL_OBJ(return_value, &intern->std);
+	return SUCCESS;
+}
+
+static void zend_internal_iterator_free(zend_object *obj) {
+	zend_internal_iterator *intern = (zend_internal_iterator *) obj;
+	if (intern->iter) {
+		zend_iterator_dtor(intern->iter);
+	}
+	zend_object_std_dtor(&intern->std);
+}
+
+static zend_internal_iterator *zend_internal_iterator_fetch(zval *This) {
+	zend_internal_iterator *intern = (zend_internal_iterator *) Z_OBJ_P(This);
+	if (!intern->iter) {
+		zend_throw_error(NULL, "The InternalIterator object has not been properly initialized");
+		return NULL;
+	}
+	return intern;
+}
+
+/* Many iterators will now behave correctly if rewind() is not called, make sure it happens. */
+static int zend_internal_iterator_ensure_rewound(zend_internal_iterator *intern) {
+	if (!intern->rewind_called) {
+		zend_object_iterator *iter = intern->iter;
+		intern->rewind_called = 1;
+		if (iter->funcs->rewind) {
+			iter->funcs->rewind(iter);
+			if (UNEXPECTED(EG(exception))) {
+				return FAILURE;
+			}
+		}
+	}
+	return SUCCESS;
+}
+
+
+ZEND_METHOD(InternalIterator, __construct) {
+	zend_throw_error(NULL, "Cannot manually construct InternalIterator");
+}
+
+ZEND_METHOD(InternalIterator, current) {
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
+	if (!intern) {
+		RETURN_THROWS();
+	}
+
+	if (zend_internal_iterator_ensure_rewound(intern) == FAILURE) {
+		RETURN_THROWS();
+	}
+
+	zval *data = intern->iter->funcs->get_current_data(intern->iter);
+	if (data) {
+		ZVAL_COPY_DEREF(return_value, data);
+	}
+}
+
+ZEND_METHOD(InternalIterator, key) {
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
+	if (!intern) {
+		RETURN_THROWS();
+	}
+
+	if (zend_internal_iterator_ensure_rewound(intern) == FAILURE) {
+		RETURN_THROWS();
+	}
+
+	if (intern->iter->funcs->get_current_key) {
+		intern->iter->funcs->get_current_key(intern->iter, return_value);
+	} else {
+		RETURN_LONG(intern->iter->index);
+	}
+}
+
+ZEND_METHOD(InternalIterator, next) {
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
+	if (!intern) {
+		RETURN_THROWS();
+	}
+
+	if (zend_internal_iterator_ensure_rewound(intern) == FAILURE) {
+		RETURN_THROWS();
+	}
+
+	intern->iter->funcs->move_forward(intern->iter);
+	intern->iter->index++;
+}
+
+ZEND_METHOD(InternalIterator, valid) {
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
+	if (!intern) {
+		RETURN_THROWS();
+	}
+
+	if (zend_internal_iterator_ensure_rewound(intern) == FAILURE) {
+		RETURN_THROWS();
+	}
+
+	RETURN_BOOL(intern->iter->funcs->valid(intern->iter) == SUCCESS);
+}
+
+ZEND_METHOD(InternalIterator, rewind) {
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
+	if (!intern) {
+		RETURN_THROWS();
+	}
+
+	if (!intern->iter->funcs->rewind) {
+		zend_throw_error(NULL, "Iterator does not support rewinding");
+		RETURN_THROWS();
+	}
+
+	intern->iter->funcs->rewind(intern->iter);
+}
+
 /* {{{ function tables */
 static const zend_function_entry zend_funcs_aggregate[] = {
 	ZEND_ABSTRACT_ME(iterator, getIterator, arginfo_class_IteratorAggregate_getIterator)
@@ -567,11 +694,23 @@ static const zend_function_entry zend_funcs_countable[] = {
 	ZEND_ABSTRACT_ME(Countable, count, arginfo_class_Countable_count)
 	ZEND_FE_END
 };
+
+static const zend_function_entry zend_funcs_internal_iterator[] = {
+	ZEND_ME(InternalIterator, __construct,  arginfo_class_InternalIterator___construct, ZEND_ACC_PRIVATE)
+	ZEND_ME(InternalIterator, current,  arginfo_class_InternalIterator_current, ZEND_ACC_PUBLIC)
+	ZEND_ME(InternalIterator, next,     arginfo_class_InternalIterator_next, ZEND_ACC_PUBLIC)
+	ZEND_ME(InternalIterator, key,      arginfo_class_InternalIterator_key, ZEND_ACC_PUBLIC)
+	ZEND_ME(InternalIterator, valid,    arginfo_class_InternalIterator_valid, ZEND_ACC_PUBLIC)
+	ZEND_ME(InternalIterator, rewind,   arginfo_class_InternalIterator_rewind, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
 /* }}} */
 
 /* {{{ zend_register_interfaces */
 ZEND_API void zend_register_interfaces(void)
 {
+	zend_class_entry ce;
+
 	REGISTER_MAGIC_INTERFACE(traversable, Traversable);
 
 	REGISTER_MAGIC_INTERFACE(aggregate, IteratorAggregate);
@@ -585,5 +724,15 @@ ZEND_API void zend_register_interfaces(void)
 	REGISTER_MAGIC_INTERFACE(serializable, Serializable);
 
 	REGISTER_MAGIC_INTERFACE(countable, Countable);
+
+	INIT_CLASS_ENTRY(ce, "InternalIterator", zend_funcs_internal_iterator);
+	zend_ce_internal_iterator = zend_register_internal_class(&ce);
+	zend_class_implements(zend_ce_internal_iterator, 1, zend_ce_iterator);
+	zend_ce_internal_iterator->ce_flags |= ZEND_ACC_FINAL;
+	zend_ce_internal_iterator->create_object = zend_internal_iterator_create;
+
+	memcpy(&zend_internal_iterator_handlers, zend_get_std_object_handlers(),
+		sizeof(zend_object_handlers));
+	zend_internal_iterator_handlers.free_obj = zend_internal_iterator_free;
 }
 /* }}} */