Convert iterable into an internal alias for Traversable|array

Author: Girgias

Zend/Optimizer/zend_inference.c

@@ -2114,9 +2114,6 @@ static uint32_t zend_convert_type_declaration_mask(uint32_t type_mask) {
 	if (type_mask & MAY_BE_CALLABLE) {
 		result_mask |= MAY_BE_STRING|MAY_BE_OBJECT|MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
 	}
-	if (type_mask & MAY_BE_ITERABLE) {
-		result_mask |= MAY_BE_OBJECT|MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
-	}
 	if (type_mask & MAY_BE_STATIC) {
 		result_mask |= MAY_BE_OBJECT;
 	}

Zend/tests/type_declarations/intersection_types/invalid_types/invalid_iterable_type.phpt

@@ -7,4 +7,4 @@ function foo(): iterable&Iterator {}
 
 ?>
 --EXPECTF--
-Fatal error: Type iterable cannot be part of an intersection type in %s on line %d
+Fatal error: Type Traversable|array cannot be part of an intersection type in %s on line %d

Zend/tests/type_declarations/intersection_types/variance/invalid5.phpt

@@ -15,4 +15,4 @@ class Test2 extends Test {
 
 ?>
 --EXPECTF--
-Fatal error: Declaration of Test2::method(): X&Y must be compatible with Test::method(): iterable in %s on line %d
+Fatal error: Declaration of Test2::method(): X&Y must be compatible with Test::method(): Traversable|array in %s on line %d

Zend/tests/type_declarations/iterable_001.phpt

@@ -45,4 +45,4 @@ object(ArrayIterator)#1 (1) {
     int(3)
   }
 }
-test(): Argument #1 ($iterable) must be of type iterable, int given, called in %s on line %d
+test(): Argument #1 ($iterable) must be of type Traversable|array, int given, called in %s on line %d

Zend/tests/type_declarations/iterable_002.phpt

@@ -17,4 +17,4 @@ function baz(iterable $iterable = 1) {
 
 ?>
 --EXPECTF--
-Fatal error: Cannot use int as default value for parameter $iterable of type iterable in %s on line %d
+Fatal error: Cannot use int as default value for parameter $iterable of type Traversable|array in %s on line %d

Zend/tests/type_declarations/iterable_003.phpt

@@ -29,4 +29,4 @@ array(0) {
 }
 object(Generator)#2 (0) {
 }
-baz(): Return value must be of type iterable, int returned
+baz(): Return value must be of type Traversable|array, int returned

Zend/tests/type_declarations/iterable_004.phpt

@@ -21,4 +21,4 @@ class Bar extends Foo {
 
 ?>
 --EXPECTF--
-Fatal error: Declaration of Bar::testScalar(iterable $iterable) must be compatible with Foo::testScalar(int $int) in %s on line %d
+Fatal error: Declaration of Bar::testScalar(Traversable|array $iterable) must be compatible with Foo::testScalar(int $int) in %s on line %d

Zend/tests/type_declarations/iterable_005.phpt

@@ -29,4 +29,4 @@ class TestScalar extends Test {
 
 ?>
 --EXPECTF--
-Fatal error: Declaration of TestScalar::method(): int must be compatible with Test::method(): iterable in %s on line %d
+Fatal error: Declaration of TestScalar::method(): int must be compatible with Test::method(): Traversable|array in %s on line %d

Zend/tests/type_declarations/union_types/redundant_types/iterable_and_Traversable.phpt

@@ -8,4 +8,4 @@ function test(): iterable|Traversable {
 
 ?>
 --EXPECTF--
-Fatal error: Type Traversable|iterable contains both iterable and Traversable, which is redundant in %s on line %d
+Fatal error: Duplicate type Traversable is redundant in %s on line %d

Zend/tests/type_declarations/union_types/redundant_types/iterable_and_Traversable_2.phpt

@@ -8,4 +8,4 @@ function test(): iterable|Traversable|ArrayAccess {
 
 ?>
 --EXPECTF--
-Fatal error: Type Traversable|ArrayAccess|iterable contains both iterable and Traversable, which is redundant in %s on line %d
+Fatal error: Duplicate type Traversable is redundant in %s on line %d

Zend/tests/type_declarations/union_types/redundant_types/iterable_and_array.phpt

@@ -8,4 +8,4 @@ function test(): iterable|array {
 
 ?>
 --EXPECTF--
-Fatal error: Type iterable|array contains both iterable and array, which is redundant in %s on line %d
+Fatal error: Duplicate type array is redundant in %s on line %d

Zend/tests/typehints/or_null.phpt

@@ -247,7 +247,7 @@ TypeError: callableF(): Argument #1 ($param) must be of type ?callable, int give
 Stack trace:
 #0 %s(52): callableF(1)
 #1 {main}
-TypeError: iterableF(): Argument #1 ($param) must be of type ?iterable, int given, called in %s:%d
+TypeError: iterableF(): Argument #1 ($param) must be of type Traversable|array|null, int given, called in %s:%d
 Stack trace:
 #0 %s(60): iterableF(1)
 #1 {main}
@@ -283,7 +283,7 @@ TypeError: returnCallable(): Return value must be of type ?callable, int returne
 Stack trace:
 #0 %s(138): returnCallable()
 #1 {main}
-TypeError: returnIterable(): Return value must be of type ?iterable, int returned in %s:%d
+TypeError: returnIterable(): Return value must be of type Traversable|array|null, int returned in %s:%d
 Stack trace:
 #0 %s(148): returnIterable()
 #1 {main}
@@ -307,7 +307,7 @@ TypeError: returnMissingCallable(): Return value must be of type ?callable, none
 Stack trace:
 #0 %s(194): returnMissingCallable()
 #1 {main}
-TypeError: returnMissingIterable(): Return value must be of type ?iterable, none returned in %s:%d
+TypeError: returnMissingIterable(): Return value must be of type Traversable|array|null, none returned in %s:%d
 Stack trace:
 #0 %s(203): returnMissingIterable()
 #1 {main}

Zend/zend_compile.c

@@ -1223,9 +1223,6 @@ zend_string *zend_type_to_string_resolved(zend_type type, zend_class_entry *scop
 	if (type_mask & MAY_BE_CALLABLE) {
 		str = add_type_string(str, ZSTR_KNOWN(ZEND_STR_CALLABLE), /* is_intersection */ false);
 	}
-	if (type_mask & MAY_BE_ITERABLE) {
-		str = add_type_string(str, ZSTR_KNOWN(ZEND_STR_ITERABLE), /* is_intersection */ false);
-	}
 	if (type_mask & MAY_BE_OBJECT) {
 		str = add_type_string(str, ZSTR_KNOWN(ZEND_STR_OBJECT), /* is_intersection */ false);
 	}
@@ -1285,7 +1282,7 @@ static void zend_mark_function_as_generator(void) /* {{{ */
 
 	if (CG(active_op_array)->fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
 		zend_type return_type = CG(active_op_array)->arg_info[-1].type;
-		bool valid_type = (ZEND_TYPE_FULL_MASK(return_type) & (MAY_BE_ITERABLE | MAY_BE_OBJECT)) != 0;
+		bool valid_type = (ZEND_TYPE_FULL_MASK(return_type) & MAY_BE_OBJECT) != 0;
 		if (!valid_type) {
 			zend_type *single_type;
 			ZEND_TYPE_FOREACH(return_type, single_type) {
@@ -6121,6 +6118,7 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 			zend_error_noreturn(E_COMPILE_ERROR,
 				"Cannot use \"static\" when no class scope is active");
 		}
+
 		return (zend_type) ZEND_TYPE_INIT_CODE(ast->attr, 0, 0);
 	} else {
 		zend_string *class_name = zend_ast_get_str(ast);
@@ -6132,6 +6130,17 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 					"Type declaration '%s' must be unqualified",
 					ZSTR_VAL(zend_string_tolower(class_name)));
 			}
+
+			/* Transform iterable into a type union alias */
+			if (type_code == IS_ITERABLE) {
+				zend_type iterable = (zend_type) ZEND_TYPE_INIT_CLASS(ZSTR_KNOWN(ZEND_STR_TRAVERSABLE), 0, 0);
+				ZEND_TYPE_FULL_MASK(iterable) |= MAY_BE_ARRAY;
+				/* Inform that the type list is a union type */
+				ZEND_TYPE_FULL_MASK(iterable) |= _ZEND_TYPE_NAME_BIT;
+				ZEND_TYPE_FULL_MASK(iterable) |= _ZEND_TYPE_UNION_BIT;
+				return iterable;
+			}
+
 			return (zend_type) ZEND_TYPE_INIT_CODE(type_code, 0, 0);
 		} else {
 			const char *correct_name;
@@ -6171,19 +6180,6 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 	}
 }
 
-static bool zend_type_contains_traversable(zend_type type) {
-	zend_type *single_type;
-	ZEND_TYPE_FOREACH(type, single_type) {
-		if (ZEND_TYPE_HAS_NAME(*single_type)
-				&& zend_string_equals_literal_ci(ZEND_TYPE_NAME(*single_type), "Traversable")) {
-			return 1;
-		}
-	} ZEND_TYPE_FOREACH_END();
-	return 0;
-}
-
-// TODO: Ideally we'd canonicalize "iterable" into "array|Traversable" and essentially
-// treat it as a built-in type alias.
 static zend_type zend_compile_typename(
 		zend_ast *ast, bool force_allow_null) /* {{{ */
 {
@@ -6278,7 +6274,7 @@ static zend_type zend_compile_typename(
 			zend_type single_type = zend_compile_single_typename(type_ast);
 
 			/* An intersection of standard types cannot exist so invalidate it */
-			if (ZEND_TYPE_IS_ONLY_MASK(single_type)) {
+			if (ZEND_TYPE_PURE_MASK(single_type)) {
 				zend_string *standard_type_str = zend_type_to_string(single_type);
 				zend_error_noreturn(E_COMPILE_ERROR,
 					"Type %s cannot be part of an intersection type", ZSTR_VAL(standard_type_str));
@@ -6316,18 +6312,6 @@ static zend_type zend_compile_typename(
 	}
 
 	uint32_t type_mask = ZEND_TYPE_PURE_MASK(type);
-	if ((type_mask & (MAY_BE_ARRAY|MAY_BE_ITERABLE)) == (MAY_BE_ARRAY|MAY_BE_ITERABLE)) {
-		zend_string *type_str = zend_type_to_string(type);
-		zend_error_noreturn(E_COMPILE_ERROR,
-			"Type %s contains both iterable and array, which is redundant", ZSTR_VAL(type_str));
-	}
-
-	if ((type_mask & MAY_BE_ITERABLE) && zend_type_contains_traversable(type)) {
-		zend_string *type_str = zend_type_to_string(type);
-		zend_error_noreturn(E_COMPILE_ERROR,
-			"Type %s contains both iterable and Traversable, which is redundant",
-			ZSTR_VAL(type_str));
-	}
 
 	if (type_mask == MAY_BE_ANY && is_marked_nullable) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Type mixed cannot be marked as nullable since mixed already includes null");
@@ -6374,9 +6358,6 @@ static bool zend_is_valid_default_value(zend_type type, zval *value)
 		convert_to_double(value);
 		return 1;
 	}
-	if ((ZEND_TYPE_FULL_MASK(type) & MAY_BE_ITERABLE) && Z_TYPE_P(value) == IS_ARRAY) {
-		return 1;
-	}
 	return 0;
 }
 

Zend/zend_execute.c

@@ -909,9 +909,6 @@ static zend_always_inline bool i_zend_check_property_type(zend_property_info *in
 
 	uint32_t type_mask = ZEND_TYPE_FULL_MASK(info->type);
 	ZEND_ASSERT(!(type_mask & (MAY_BE_CALLABLE|MAY_BE_STATIC)));
-	if ((type_mask & MAY_BE_ITERABLE) && zend_is_iterable(property)) {
-		return 1;
-	}
 	return zend_verify_scalar_type_hint(type_mask, property, strict, 0);
 }
 
@@ -1048,9 +1045,6 @@ static zend_always_inline bool zend_check_type_slow(
 	if ((type_mask & MAY_BE_CALLABLE) && zend_is_callable(arg, 0, NULL)) {
 		return 1;
 	}
-	if ((type_mask & MAY_BE_ITERABLE) && zend_is_iterable(arg)) {
-		return 1;
-	}
 	if ((type_mask & MAY_BE_STATIC) && zend_value_instanceof_static(arg)) {
 		return 1;
 	}
@@ -2929,7 +2923,7 @@ static zend_always_inline bool check_type_array_assignable(zend_type type) {
 	if (!ZEND_TYPE_IS_SET(type)) {
 		return 1;
 	}
-	return (ZEND_TYPE_FULL_MASK(type) & (MAY_BE_ITERABLE|MAY_BE_ARRAY)) != 0;
+	return (ZEND_TYPE_FULL_MASK(type) & MAY_BE_ARRAY) != 0;
 }
 
 /* Checks whether an array can be assigned to the reference. Throws error if not assignable. */
@@ -3378,9 +3372,6 @@ static zend_always_inline int i_zend_verify_type_assignable_zval(
 
 	type_mask = ZEND_TYPE_FULL_MASK(type);
 	ZEND_ASSERT(!(type_mask & (MAY_BE_CALLABLE|MAY_BE_STATIC)));
-	if (type_mask & MAY_BE_ITERABLE) {
-		return zend_is_iterable(zv);
-	}
 
 	/* SSTH Exception: IS_LONG may be accepted as IS_DOUBLE (converted) */
 	if (strict) {

Zend/zend_inheritance.c

@@ -327,21 +327,6 @@ static bool unlinked_instanceof(zend_class_entry *ce1, zend_class_entry *ce2) {
 	return 0;
 }
 
-static bool zend_type_contains_traversable(zend_type type) {
-	zend_type *single_type;
-	if (ZEND_TYPE_FULL_MASK(type) & MAY_BE_OBJECT) {
-		return 1;
-	}
-
-	ZEND_TYPE_FOREACH(type, single_type) {
-		if (ZEND_TYPE_HAS_NAME(*single_type)
-				&& zend_string_equals_literal_ci(ZEND_TYPE_NAME(*single_type), "Traversable")) {
-			return 1;
-		}
-	} ZEND_TYPE_FOREACH_END();
-	return 0;
-}
-
 static bool zend_type_permits_self(
 		zend_type type, zend_class_entry *scope, zend_class_entry *self) {
 	if (ZEND_TYPE_FULL_MASK(type) & MAY_BE_OBJECT) {
@@ -472,15 +457,6 @@ static inheritance_status zend_is_class_subtype_of_type(
 			return INHERITANCE_SUCCESS;
 		}
 	}
-	if (ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_ITERABLE) {
-		if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
-		if (!fe_ce) {
-			have_unresolved = 1;
-		} else if (unlinked_instanceof(fe_ce, zend_ce_traversable)) {
-			track_class_dependency(fe_ce, fe_class_name);
-			return INHERITANCE_SUCCESS;
-		}
-	}
 
 	zend_type *single_type;
 
@@ -566,18 +542,6 @@ static inheritance_status zend_perform_covariant_type_check(
 	uint32_t proto_type_mask = ZEND_TYPE_PURE_MASK(proto_type);
 	uint32_t added_types = fe_type_mask & ~proto_type_mask;
 	if (added_types) {
-		// TODO: Make "iterable" an alias of "array|Traversable" instead,
-		// so these special cases will be handled automatically.
-		if ((added_types & MAY_BE_ITERABLE)
-				&& (proto_type_mask & MAY_BE_ARRAY)
-				&& zend_type_contains_traversable(proto_type)) {
-			/* Replacing array|Traversable with iterable is okay */
-			added_types &= ~MAY_BE_ITERABLE;
-		}
-		if ((added_types & MAY_BE_ARRAY) && (proto_type_mask & MAY_BE_ITERABLE)) {
-			/* Replacing iterable with array is okay */
-			added_types &= ~MAY_BE_ARRAY;
-		}
 		if ((added_types & MAY_BE_STATIC)
 				&& zend_type_permits_self(proto_type, proto_scope, fe_scope)) {
 			/* Replacing type that accepts self with static is okay */
@@ -604,19 +568,16 @@ static inheritance_status zend_perform_covariant_type_check(
 		 * We still perform a class lookup for forward-compatibility reasons,
 		 * as we may have named types in the future that are not classes
 		 * (such as typedefs). */
-		if (proto_type_mask & (MAY_BE_OBJECT|MAY_BE_ITERABLE)) {
-			bool any_class = (proto_type_mask & MAY_BE_OBJECT) != 0;
+		if (proto_type_mask & MAY_BE_OBJECT) {
 			ZEND_TYPE_FOREACH(fe_type, single_type) {
 				zend_string *fe_class_name = get_class_from_type(fe_scope, *single_type);
 				if (!fe_class_name) {
 					continue;
 				}
 				zend_class_entry *fe_ce = lookup_class(fe_scope, fe_class_name);
 				if (fe_ce) {
-					if (any_class || unlinked_instanceof(fe_ce, zend_ce_traversable)) {
-						track_class_dependency(fe_ce, fe_class_name);
-						return INHERITANCE_SUCCESS;
-					}
+					track_class_dependency(fe_ce, fe_class_name);
+					return INHERITANCE_SUCCESS;
 				} else {
 					have_unresolved = true;
 				}

Zend/zend_string.h

@@ -580,6 +580,7 @@ EMPTY_SWITCH_DEFAULT_CASE()
 	_(ZEND_STR_FALSE,                  "false") \
 	_(ZEND_STR_NULL_LOWERCASE,         "null") \
 	_(ZEND_STR_MIXED,                  "mixed") \
+	_(ZEND_STR_TRAVERSABLE,            "Traversable") \
 	_(ZEND_STR_SLEEP,                  "__sleep") \
 	_(ZEND_STR_WAKEUP,                 "__wakeup") \
 	_(ZEND_STR_CASES,                  "cases") \

Zend/zend_type_info.h

@@ -38,7 +38,6 @@
 /* These are used in zend_type, but not for type inference.
  * They are allowed to overlap with types used during inference. */
 #define MAY_BE_CALLABLE             (1 << IS_CALLABLE)
-#define MAY_BE_ITERABLE             (1 << IS_ITERABLE)
 #define MAY_BE_VOID                 (1 << IS_VOID)
 #define MAY_BE_NEVER                (1 << IS_NEVER)
 #define MAY_BE_STATIC               (1 << IS_STATIC)

ext/opcache/jit/zend_jit_arm64.dasc

@@ -12231,7 +12231,7 @@ static int zend_jit_fetch_obj(dasm_State          **Dst,
 			uint32_t flags = opline->extended_value & ZEND_FETCH_OBJ_FLAGS;
 
 			if (flags == ZEND_FETCH_DIM_WRITE) {
-				if ((ZEND_TYPE_FULL_MASK(prop_info->type) & (MAY_BE_ITERABLE|MAY_BE_ARRAY)) == 0) {
+				if ((ZEND_TYPE_FULL_MASK(prop_info->type) & MAY_BE_ARRAY) == 0) {
 					if (!type_loaded) {
 						type_loaded = 1;
 						|	MEM_ACCESS_32_WITH_UOFFSET ldr, REG2w, FCARG1x, (prop_info->offset + offsetof(zval,u1.type_info)), TMP1

ext/opcache/jit/zend_jit_helpers.c

@@ -1949,7 +1949,7 @@ static zend_always_inline bool check_type_array_assignable(zend_type type) {
 	if (!ZEND_TYPE_IS_SET(type)) {
 		return 1;
 	}
-	return (ZEND_TYPE_FULL_MASK(type) & (MAY_BE_ITERABLE|MAY_BE_ARRAY)) != 0;
+	return (ZEND_TYPE_FULL_MASK(type) & MAY_BE_ARRAY) != 0;
 }
 
 static zend_property_info *zend_object_fetch_property_type_info(
@@ -2094,7 +2094,7 @@ static void ZEND_FASTCALL zend_jit_check_array_promotion(zval *val, zend_propert
 	if ((Z_TYPE_P(val) <= IS_FALSE
 		|| (Z_ISREF_P(val) && Z_TYPE_P(Z_REFVAL_P(val)) <= IS_FALSE))
 		&& ZEND_TYPE_IS_SET(prop->type)
-		&& (ZEND_TYPE_FULL_MASK(prop->type) & (MAY_BE_ITERABLE|MAY_BE_ARRAY)) == 0) {
+		&& (ZEND_TYPE_FULL_MASK(prop->type) & MAY_BE_ARRAY) == 0) {
 		zend_string *type_str = zend_type_to_string(prop->type);
 		zend_type_error(
 			"Cannot auto-initialize an array inside property %s::$%s of type %s",

ext/opcache/jit/zend_jit_x86.dasc

@@ -12962,7 +12962,7 @@ static int zend_jit_fetch_obj(dasm_State          **Dst,
 			uint32_t flags = opline->extended_value & ZEND_FETCH_OBJ_FLAGS;
 
 			if (flags == ZEND_FETCH_DIM_WRITE) {
-				if ((ZEND_TYPE_FULL_MASK(prop_info->type) & (MAY_BE_ITERABLE|MAY_BE_ARRAY)) == 0) {
+				if ((ZEND_TYPE_FULL_MASK(prop_info->type) & MAY_BE_ARRAY) == 0) {
 					if (!type_loaded) {
 						type_loaded = 1;
 						|	mov edx, dword [FCARG1a + prop_info->offset + 8]

ext/opcache/tests/iterable_type_optimization.phpt

@@ -12,7 +12,7 @@ test(new stdClass);
 
 ?>
 --EXPECTF--
-Fatal error: Uncaught TypeError: test(): Return value must be of type iterable, stdClass returned in %s:%d
+Fatal error: Uncaught TypeError: test(): Return value must be of type Traversable|array, stdClass returned in %s:%d
 Stack trace:
 #0 %s(%d): test(Object(stdClass))
 #1 {main}

ext/reflection/php_reflection.c

@@ -3080,9 +3080,6 @@ ZEND_METHOD(ReflectionUnionType, getTypes)
 	if (type_mask & MAY_BE_CALLABLE) {
 		append_type_mask(return_value, MAY_BE_CALLABLE);
 	}
-	if (type_mask & MAY_BE_ITERABLE) {
-		append_type_mask(return_value, MAY_BE_ITERABLE);
-	}
 	if (type_mask & MAY_BE_OBJECT) {
 		append_type_mask(return_value, MAY_BE_OBJECT);
 	}

ext/reflection/tests/ReflectionClass_isArray.phpt

@@ -21,7 +21,7 @@ Deprecated: Method ReflectionParameter::isArray() is deprecated in %s on line %d
 bool(true)
 
 Deprecated: Method ReflectionParameter::isArray() is deprecated in %s on line %d
-bool(false)
+bool(true)
 
 Deprecated: Method ReflectionParameter::isArray() is deprecated in %s on line %d
 bool(false)