Make generic type declarations aware of the inner type

Author: Girgias

Zend/tests/type_declarations/abstract_generics/generic_parameter_declarations/property_basic.phpt

@@ -37,7 +37,7 @@ var_dump($t);
 --EXPECT--
 object(T)#3 (0) {
   ["v"]=>
-  uninitialized(I)
+  uninitialized(I<string>)
 }
 object(T)#3 (1) {
   ["v"]=>

Zend/tests/type_declarations/abstract_generics/generic_parameter_declarations/property_multiple.phpt

@@ -0,0 +1,51 @@
+--TEST--
+Property generic class as type
+--FILE--
+<?php
+
+interface I<T1, T2> {
+    public function foo(T1 $param): T2;
+}
+
+class CS implements I<string, string> {
+    public function foo(string $param): string {
+        return $param . '!';
+    }
+}
+
+class CI implements I<int, int> {
+    public function foo(int $param): int {
+        return $param + 42;
+    }
+}
+
+class T {
+	public I<string, string> $v;
+}
+
+$cs = new CS();
+$ci = new CI();
+
+$t = new T();
+var_dump($t);
+$t->v = $cs;
+var_dump($t);
+$t->v = $ci;
+var_dump($t);
+
+?>
+--EXPECT--
+object(T)#3 (0) {
+  ["v"]=>
+  uninitialized(I<string, string>)
+}
+object(T)#3 (1) {
+  ["v"]=>
+  object(CS)#1 (0) {
+  }
+}
+object(T)#3 (1) {
+  ["v"]=>
+  object(CI)#2 (0) {
+  }
+}

Zend/zend_compile.c

@@ -39,6 +39,7 @@
 #include "zend_call_stack.h"
 #include "zend_frameless_function.h"
 #include "zend_property_hooks.h"
+#include "zend_smart_str.h"
 
 #define SET_NODE(target, src) do { \
 		target ## _type = (src)->op_type; \
@@ -1484,6 +1485,29 @@ zend_string *zend_type_to_string_resolved(const zend_type type, const zend_class
 	if (ZEND_TYPE_IS_INTERSECTION(type)) {
 		ZEND_ASSERT(!ZEND_TYPE_IS_UNION(type));
 		str = add_intersection_type(str, ZEND_TYPE_LIST(type), /* is_bracketed */ false);
+	} else if (ZEND_TYPE_IS_NAME_WITH_GENERIC_TYPES(type)) {
+		const zend_type *single_type;
+		bool is_class_name = true;
+		bool just_after_class_name = true;
+
+		smart_str class_with_generic = {0};
+		ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(type), single_type) {
+			if (is_class_name) {
+				ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*single_type));
+				smart_str_append(&class_with_generic, resolve_class_name(ZEND_TYPE_NAME(*single_type), scope));
+				smart_str_appendc(&class_with_generic, '<');
+				is_class_name = false;
+				continue;
+			}
+			if (!just_after_class_name) {
+				smart_str_appends(&class_with_generic, ", ");
+			}
+			just_after_class_name = false;
+			smart_str_append(&class_with_generic, zend_type_to_string_resolved(*single_type, scope, bound_types_to_scope));
+		} ZEND_TYPE_LIST_FOREACH_END();
+		smart_str_appendc(&class_with_generic, '>');
+		str = smart_str_extract(&class_with_generic);
+		smart_str_free(&class_with_generic);
 	} else if (ZEND_TYPE_HAS_LIST(type)) {
 		/* A union type might not be a list */
 		const zend_type *list_type;
@@ -7413,6 +7437,8 @@ ZEND_API void zend_set_function_arg_flags(zend_function *func) /* {{{ */
 }
 /* }}} */
 
+static zend_type zend_compile_typename(zend_ast *ast);
+
 static zend_type zend_compile_single_typename(zend_ast *ast)
 {
 	const zend_class_entry *ce = CG(active_class_entry);
@@ -7512,7 +7538,32 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 			class_name = zend_new_interned_string(class_name);
 			zend_alloc_ce_cache(class_name);
 			// TODO: use args_ast
-			return (zend_type) ZEND_TYPE_INIT_CLASS(class_name, /* allow null */ false, 0);
+			if (args_ast) {
+				ZEND_ASSERT(args_ast->kind == ZEND_AST_GENERIC_ARG_LIST);
+				const zend_ast_list *list = zend_ast_get_list(args_ast);
+
+				/* Allocate the type list directly on the arena as it must be a type
+				 * list of the number of AST childs + 1 for the class name */
+				zend_type_list *type_list = zend_arena_alloc(&CG(arena), ZEND_TYPE_LIST_SIZE(list->children + 1));
+				type_list->num_types = 0;
+				/* Add type to the type list */
+				type_list->types[type_list->num_types++] = (zend_type) ZEND_TYPE_INIT_CLASS(class_name, /* allow null */ false, 0);
+
+				for (uint32_t i = 0; i < list->children; i++) {
+					zend_ast *generic_arg_type_ast = list->child[i];
+					type_list->types[type_list->num_types++] = zend_compile_typename(generic_arg_type_ast);
+				}
+				ZEND_ASSERT(list->children+1 == type_list->num_types);
+
+				zend_type type = ZEND_TYPE_INIT_NONE(0);
+				ZEND_TYPE_SET_LIST(type, type_list);
+				/* Inform that the type list is a class name with bound types */
+				ZEND_TYPE_FULL_MASK(type) |= _ZEND_TYPE_NAME_WITH_BOUND_TYPES;
+				ZEND_TYPE_FULL_MASK(type) |= _ZEND_TYPE_ARENA_BIT;
+				return type;
+			} else {
+				return (zend_type) ZEND_TYPE_INIT_CLASS(class_name, /* allow null */ false, 0);
+			}
 		}
 	}
 }
@@ -7599,8 +7650,6 @@ static void zend_is_type_list_redundant_by_single_type(const zend_type_list *typ
 	}
 }
 
-static zend_type zend_compile_typename(zend_ast *ast);
-
 static zend_type zend_compile_typename_ex(
 		zend_ast *ast, bool force_allow_null, bool *forced_allow_null) /* {{{ */
 {

Zend/zend_types.h

@@ -135,9 +135,10 @@ typedef struct {
 	zend_type constraint;
 } zend_generic_parameter;
 
-#define _ZEND_TYPE_EXTRA_FLAGS_SHIFT 26
-#define _ZEND_TYPE_MASK ((1u << 26) - 1)
+#define _ZEND_TYPE_EXTRA_FLAGS_SHIFT 27
+#define _ZEND_TYPE_MASK ((1u << 27) - 1)
 /* Only one of these bits may be set. */
+#define _ZEND_TYPE_NAME_WITH_BOUND_TYPES (1u << 26)
 #define _ZEND_TYPE_GENERIC_PARAM_NAME_BIT (1u << 25)
 #define _ZEND_TYPE_NAME_BIT (1u << 24)
 // Used to signify that type.ptr is not a `zend_string*` but a `const char*`,
@@ -171,6 +172,9 @@ typedef struct {
 #define ZEND_TYPE_HAS_LITERAL_NAME(t) \
 	((((t).type_mask) & _ZEND_TYPE_LITERAL_NAME_BIT) != 0)
 
+#define ZEND_TYPE_IS_NAME_WITH_GENERIC_TYPES(t) \
+	((((t).type_mask) & _ZEND_TYPE_NAME_WITH_BOUND_TYPES) != 0)
+
 #define ZEND_TYPE_HAS_LIST(t) \
 	((((t).type_mask) & _ZEND_TYPE_LIST_BIT) != 0)