Reflection iterable BC for named types

Author: Girgias

ext/reflection/php_reflection.c

@@ -1330,7 +1330,7 @@ typedef enum {
 } reflection_type_kind;
 
 /* For backwards compatibility reasons, we need to return T|null style unions
- * ~~and transformation from iterable to Traversable|array~~
+ * and transformation from iterable to Traversable|array
  * as a ReflectionNamedType. Here we determine what counts as a union type and
  * what doesn't. */
 static reflection_type_kind get_type_kind(zend_type type) {
@@ -1346,11 +1346,9 @@ static reflection_type_kind get_type_kind(zend_type type) {
 
 	if (ZEND_TYPE_IS_COMPLEX(type)) {
 		/* BC support for 'iterable' type */
-		/*
 		if (UNEXPECTED(ZEND_TYPE_IS_ITERABLE_FALLBACK(type))) {
 			return NAMED_TYPE;
 		}
-		*/
 		if (type_mask_without_null != 0) {
 			return UNION_TYPE;
 		}
@@ -3018,9 +3016,21 @@ ZEND_METHOD(ReflectionType, allowsNull)
 }
 /* }}} */
 
+/* For BC with iterable for named types */
+static zend_string *zend_named_reflection_type_to_string(zend_type type) {
+	if (ZEND_TYPE_IS_ITERABLE_FALLBACK(type)) {
+		zend_string *iterable = ZSTR_KNOWN(ZEND_STR_ITERABLE);
+		if (ZEND_TYPE_FULL_MASK(type) & MAY_BE_NULL) {
+			return zend_string_concat2("?", strlen("?"), ZSTR_VAL(iterable), ZSTR_LEN(iterable));
+		}
+		return iterable;
+	}
+	return zend_type_to_string(type);
+}
+
 static zend_string *zend_type_to_string_without_null(zend_type type) {
 	ZEND_TYPE_FULL_MASK(type) &= ~MAY_BE_NULL;
-	return zend_type_to_string(type);
+	return zend_named_reflection_type_to_string(type);
 }
 
 /* {{{ Return the text of the type hint */
@@ -3034,7 +3044,7 @@ ZEND_METHOD(ReflectionType, __toString)
 	}
 	GET_REFLECTION_OBJECT_PTR(param);
 
-	RETURN_STR(zend_type_to_string(param->type));
+	RETURN_STR(zend_named_reflection_type_to_string(param->type));
 }
 /* }}} */
 
@@ -3052,7 +3062,7 @@ ZEND_METHOD(ReflectionNamedType, getName)
 	if (param->legacy_behavior) {
 		RETURN_STR(zend_type_to_string_without_null(param->type));
 	}
-	RETURN_STR(zend_type_to_string(param->type));
+	RETURN_STR(zend_named_reflection_type_to_string(param->type));
 }
 /* }}} */
 
@@ -3067,6 +3077,10 @@ ZEND_METHOD(ReflectionNamedType, isBuiltin)
 	}
 	GET_REFLECTION_OBJECT_PTR(param);
 
+	if (ZEND_TYPE_IS_ITERABLE_FALLBACK(param->type)) {
+		RETURN_TRUE;
+	}
+
 	/* Treat "static" as a class type for the purposes of reflection. */
 	RETVAL_BOOL(ZEND_TYPE_IS_ONLY_MASK(param->type)
 		&& !(ZEND_TYPE_FULL_MASK(param->type) & MAY_BE_STATIC));
@@ -3075,6 +3089,11 @@ ZEND_METHOD(ReflectionNamedType, isBuiltin)
 
 static void append_type(zval *return_value, zend_type type) {
 	zval reflection_type;
+	/* Drop iterable BC bit for type list */
+	if (ZEND_TYPE_IS_ITERABLE_FALLBACK(type)) {
+		ZEND_TYPE_FULL_MASK(type) &= ~_ZEND_TYPE_ITERABLE_BIT;
+	}
+
 	reflection_type_factory(type, &reflection_type, 0);
 	zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &reflection_type);
 }

ext/reflection/tests/bug72661.phpt

@@ -3,33 +3,96 @@ iterable Type in Reflection
 --FILE--
 <?php
 
-$function = function(): iterable {};
+$function = function(iterable $arg): iterable {};
+
+$paramType = (new ReflectionParameter($function, 0))->getType();
+var_dump($paramType::class);
+var_dump($paramType);
+var_dump($paramType->getName());
+var_dump((string) $paramType);
+var_dump($paramType->isBuiltin());
 
 $reflectionFunc = new ReflectionFunction($function);
 $returnType = $reflectionFunc->getReturnType();
 var_dump($returnType::class);
-foreach ($returnType->getTypes() as $type) {
-    var_dump($type->getName());
-}
+var_dump($returnType);
+var_dump($returnType->getName());
+var_dump((string) $returnType);
+var_dump($returnType->isBuiltin());
 
 class PropIterableTypeTest {
     public iterable $iterable;
+    public ?iterable $nullableIterable;
+    public array $control;
+    public ?array $nullableControl;
 }
 
 $reflector = new ReflectionClass(PropIterableTypeTest::class);
 
-[$property] = $reflector->getProperties();
+[$property, $nullable, $control, $nullableControl] = $reflector->getProperties();
 $iterableType = $property->getType();
 var_dump($iterableType::class);
-foreach ($iterableType->getTypes() as $type) {
-    var_dump($type->getName());
-}
+var_dump($iterableType);
+var_dump($iterableType->getName());
+var_dump((string) $iterableType);
+var_dump($iterableType->isBuiltin());
+
+$nullableIterableType = $nullable->getType();
+var_dump($nullableIterableType::class);
+var_dump($nullableIterableType);
+var_dump($nullableIterableType->getName());
+var_dump((string) $nullableIterableType);
+var_dump($nullableIterableType->isBuiltin());
+
+$controlType = $control->getType();
+var_dump($controlType::class);
+var_dump($controlType);
+var_dump($controlType->getName());
+var_dump((string) $controlType);
+var_dump($controlType->isBuiltin());
+
+$nullableControlType = $nullableControl->getType();
+var_dump($nullableControlType::class);
+var_dump($nullableControlType);
+var_dump($nullableControlType->getName());
+var_dump((string) $nullableControlType);
+var_dump($nullableControlType->isBuiltin());
 
 ?>
---EXPECT--
-string(19) "ReflectionUnionType"
-string(11) "Traversable"
+--EXPECTF--
+string(19) "ReflectionNamedType"
+object(ReflectionNamedType)#%d (0) {
+}
+string(8) "iterable"
+string(8) "iterable"
+bool(true)
+string(19) "ReflectionNamedType"
+object(ReflectionNamedType)#%d (0) {
+}
+string(8) "iterable"
+string(8) "iterable"
+bool(true)
+string(19) "ReflectionNamedType"
+object(ReflectionNamedType)#%d (0) {
+}
+string(8) "iterable"
+string(8) "iterable"
+bool(true)
+string(19) "ReflectionNamedType"
+object(ReflectionNamedType)#%d (0) {
+}
+string(8) "iterable"
+string(9) "?iterable"
+bool(true)
+string(19) "ReflectionNamedType"
+object(ReflectionNamedType)#%d (0) {
+}
+string(5) "array"
 string(5) "array"
-string(19) "ReflectionUnionType"
-string(11) "Traversable"
+bool(true)
+string(19) "ReflectionNamedType"
+object(ReflectionNamedType)#%d (0) {
+}
 string(5) "array"
+string(6) "?array"
+bool(true)