Something works...

Author: nikic

Zend/tests/generics/basic.phpt

@@ -0,0 +1,20 @@
+--TEST--
+Basic generic class declaration
+--FILE--
+<?php
+
+interface I<T> {
+}
+
+class C<T> {
+}
+
+final class F<T> {
+}
+
+trait T<T> {
+}
+
+?>
+--EXPECT--
+

Zend/tests/generics/duplicate_generic_param.phpt

@@ -0,0 +1,11 @@
+--TEST--
+Duplicate generic parameter name
+--FILE--
+<?php
+
+class Test<T, T> {
+}
+
+?>
+--EXPECTF--
+Fatal error: Duplicate generic parameter T in %s on line %d

Zend/tests/generics/inheritance_bind_parent_param.phpt

@@ -0,0 +1,27 @@
+--TEST--
+Bind direct parent parameter during inheritance
+--FILE--
+<?php
+
+abstract class WithParam<T> {
+    public function method(T $param) {
+        var_dump($param);
+    }
+}
+
+class Concrete extends WithParam<int> {
+}
+
+$obj = new Concrete;
+$obj->method(42);
+
+try {
+    $obj->method("string");
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+int(42)
+Argument 1 passed to WithParam::method() must be of type T (where T = int), string given, called in %s on line %d

Zend/zend.h

@@ -107,6 +107,11 @@ typedef struct _zend_trait_alias {
 	uint32_t modifiers;
 } zend_trait_alias;
 
+typedef struct _zend_generic_param {
+	zend_string *name;
+	zend_type type;
+} zend_generic_param;
+
 struct _zend_class_entry {
 	char type;
 	zend_string *name;
@@ -171,6 +176,17 @@ struct _zend_class_entry {
 	zend_trait_alias **trait_aliases;
 	zend_trait_precedence **trait_precedences;
 
+	/* generic_params are the free generic parameters on this class.
+	 * parent_generic_args are the bound generic parameters of parent classes.
+	 * Pre-inheritance, this only includes what we pass to the direct parent.
+	 * During inheritance, any bound parameters from parent parameters will be
+	 * included before our own, and all generic parameter IDs will be shifted
+	 * accordingly. */
+	uint32_t num_generic_params;
+	uint32_t num_parent_generic_args;
+	zend_generic_param *generic_params;
+	zend_type *parent_generic_args;
+
 	union {
 		struct {
 			zend_string *filename;

Zend/zend_compile.c

@@ -1177,6 +1177,9 @@ zend_string *zend_type_to_string_resolved(zend_type type, zend_class_entry *scop
 		str = zend_string_copy(resolve_class_name(ZEND_TYPE_NAME(type), scope));
 	} else if (ZEND_TYPE_HAS_CE(type)) {
 		str = zend_string_copy(ZEND_TYPE_CE(type)->name);
+	} else if (ZEND_TYPE_HAS_GENERIC_PARAM(type)) {
+		zend_generic_param *param = &scope->generic_params[ZEND_TYPE_GENERIC_PARAM_ID(type)];
+		str = zend_string_copy(param->name);
 	}
 
 	uint32_t type_mask = ZEND_TYPE_FULL_MASK(type);
@@ -1519,6 +1522,39 @@ static zend_string *zend_resolve_const_class_name_reference(zend_ast *class_ast,
 	return zend_resolve_class_name(class_name, name_ast->attr);
 }
 
+static zend_type zend_compile_typename(
+		zend_ast *ast, zend_bool force_allow_null, zend_bool use_arena);
+
+static zend_type *zend_compile_generic_args(zend_ast *args_ast, uint32_t *num_args) {
+	zend_ast_list *list = zend_ast_get_list(args_ast);
+	zend_type *types = emalloc(sizeof(zend_type) * list->children);
+	*num_args = list->children;
+	for (uint32_t i = 0; i < list->children; i++) {
+		zend_ast *type_ast = list->child[0];
+		types[i] = zend_compile_typename(type_ast, 0, 0);
+	}
+	return types;
+}
+
+static zend_string *zend_compile_const_class_name_reference(
+		zend_ast *class_ast, const char *type, uint32_t *num_generic_args, zend_type **generic_args) {
+	zend_ast *name_ast = class_ast->child[0];
+	zend_string *class_name = zend_ast_get_str(name_ast);
+	if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type_ast(name_ast)) {
+		zend_error_noreturn(E_COMPILE_ERROR,
+			"Cannot use '%s' as %s, as it is reserved",
+			ZSTR_VAL(class_name), type);
+	}
+	class_name = zend_resolve_class_name(class_name, name_ast->attr);
+	if (class_ast->child[1]) {
+		*generic_args = zend_compile_generic_args(class_ast->child[1], num_generic_args);
+	} else {
+		*num_generic_args = 0;
+		*generic_args = NULL;
+	}
+	return class_name;
+}
+
 static void zend_ensure_valid_class_fetch_type(uint32_t fetch_type) /* {{{ */
 {
 	if (fetch_type != ZEND_FETCH_CLASS_DEFAULT && zend_is_scope_known()) {
@@ -1833,6 +1869,8 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify
 		ce->num_interfaces = 0;
 		ce->interfaces = NULL;
 		ce->num_traits = 0;
+		ce->num_generic_params = 0;
+		ce->num_parent_generic_args = 0;
 		ce->trait_names = NULL;
 		ce->trait_aliases = NULL;
 		ce->trait_precedences = NULL;
@@ -5483,6 +5521,20 @@ ZEND_API void zend_set_function_arg_flags(zend_function *func) /* {{{ */
 }
 /* }}} */
 
+static uint32_t lookup_generic_param_id(zend_string *name) {
+	if (!CG(active_class_entry) || CG(active_class_entry)->num_generic_params == 0) {
+		return (uint32_t) -1;
+	}
+
+	for (uint32_t i = 0; i < CG(active_class_entry)->num_generic_params; i++) {
+		zend_generic_param *param = &CG(active_class_entry)->generic_params[i];
+		if (zend_string_equals(param->name, name)) {
+			return i;
+		}
+	}
+	return (uint32_t) -1;
+}
+
 static zend_type zend_compile_single_typename(zend_ast *ast)
 {
 	ZEND_ASSERT(!(ast->attr & ZEND_TYPE_NULLABLE));
@@ -5502,6 +5554,11 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 		} else {
 			const char *correct_name;
 			zend_string *orig_name = zend_ast_get_str(ast);
+			uint32_t generic_param_id = lookup_generic_param_id(orig_name);
+			if (ast->attr == ZEND_NAME_NOT_FQ && generic_param_id != (uint32_t) -1) {
+				return (zend_type) ZEND_TYPE_INIT_GENERIC_PARAM(generic_param_id, 0);
+			}
+
 			uint32_t fetch_type = zend_get_class_fetch_type_ast(ast);
 			if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) {
 				class_name = zend_resolve_class_name_ast(ast);
@@ -6552,12 +6609,40 @@ static zend_string *zend_generate_anon_class_name(uint32_t start_lineno) /* {{{
 }
 /* }}} */
 
+static void zend_compile_generic_params(zend_ast *params_ast)
+{
+	zend_ast_list *list = zend_ast_get_list(params_ast);
+	zend_generic_param *generic_params = emalloc(list->children * sizeof(zend_generic_param));
+	for (uint32_t i = 0; i < list->children; i++) {
+		zend_ast *param_ast = list->child[i];
+		zend_string *name = zend_ast_get_str(param_ast->child[0]);
+		for (uint32_t j = 0; j < i; j++) {
+			if (zend_string_equals(name, generic_params[j].name)) {
+				zend_error(E_COMPILE_ERROR, "Duplicate generic parameter %s", ZSTR_VAL(name));
+			}
+		}
+
+		generic_params[i].name = zend_string_copy(name);
+		if (param_ast->child[1]) {
+			generic_params[i].type = zend_compile_typename(param_ast->child[1], 0, 0);
+			// TODO: Validate potential additional constraints on the type bound.
+			// For example, can "void" be used?
+		} else {
+			generic_params[i].type = (zend_type) ZEND_TYPE_INIT_NONE(0);
+		}
+	}
+
+	CG(active_class_entry)->num_generic_params = list->children;
+	CG(active_class_entry)->generic_params = generic_params;
+}
+
 zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */
 {
 	zend_ast_decl *decl = (zend_ast_decl *) ast;
 	zend_ast *extends_ast = decl->child[0];
 	zend_ast *implements_ast = decl->child[1];
 	zend_ast *stmt_ast = decl->child[2];
+	zend_ast *generic_params_ast = decl->child[3];
 	zend_string *name, *lcname;
 	zend_class_entry *ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
 	zend_op *opline;
@@ -6617,13 +6702,17 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */
 	}
 
 	if (extends_ast) {
-		ce->parent_name =
-			zend_resolve_const_class_name_reference(extends_ast, "class name");
+		ce->parent_name = zend_compile_const_class_name_reference(
+			extends_ast, "class name", &ce->num_parent_generic_args, &ce->parent_generic_args);
 		ce->ce_flags |= ZEND_ACC_INHERITED;
 	}
 
 	CG(active_class_entry) = ce;
 
+	if (generic_params_ast) {
+		zend_compile_generic_params(generic_params_ast);
+	}
+
 	zend_compile_stmt(stmt_ast);
 
 	/* Reset lineno for final opcodes and errors */

Zend/zend_execute.c

@@ -640,10 +640,10 @@ static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_throw_non_object_erro
 	}
 }
 
-/* Test used to preserve old error messages for non-union types.
+/* Test used to preserve old error messages for simple types.
  * We might want to canonicalize all type errors instead. */
-static zend_bool is_union_type(zend_type type) {
-	if (ZEND_TYPE_HAS_LIST(type)) {
+static zend_bool is_complex_type(zend_type type) {
+	if (ZEND_TYPE_HAS_LIST(type) || ZEND_TYPE_HAS_GENERIC_PARAM(type)) {
 		return 1;
 	}
 	uint32_t type_mask_without_null = ZEND_TYPE_PURE_MASK_WITHOUT_NULL(type);
@@ -673,11 +673,26 @@ static ZEND_COLD void zend_verify_type_error_common(
 		*fclass = "";
 	}
 
-	if (is_union_type(arg_info->type)) {
-		zend_string *type_str = zend_type_to_string(arg_info->type);
+	if (is_complex_type(arg_info->type)) {
+		zend_string *type_str = zend_type_to_string_resolved(arg_info->type, zf->common.scope);
 		smart_str_appends(&str, "be of type ");
 		smart_str_append(&str, type_str);
 		zend_string_release(type_str);
+
+		if (ZEND_TYPE_HAS_GENERIC_PARAM(arg_info->type)) {
+			// TODO: It's all a hack...
+			zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data));
+			uint32_t generic_param_id = ZEND_TYPE_GENERIC_PARAM_ID(arg_info->type);
+			zend_generic_param *param = &zf->common.scope->generic_params[generic_param_id];
+			zend_type real_type = called_scope->parent_generic_args[generic_param_id];
+			zend_string *real_type_string = zend_type_to_string(real_type);
+			smart_str_appends(&str, " (where ");
+			smart_str_append(&str, param->name);
+			smart_str_appends(&str, " = ");
+			smart_str_append(&str, real_type_string);
+			smart_str_appendc(&str, ')');
+			zend_string_release(real_type_string);
+		}
 	} else if (ZEND_TYPE_HAS_CLASS(arg_info->type)) {
 		zend_bool is_interface = 0;
 		zend_class_entry *ce = *cache_slot;
@@ -1067,6 +1082,19 @@ static zend_always_inline zend_bool zend_check_type_slow(
 	}
 
 builtin_types:
+	if (ZEND_TYPE_HAS_GENERIC_PARAM(type)) {
+		// TODO: This doesn't handle free generic parameters.
+		uint32_t param_id = ZEND_TYPE_GENERIC_PARAM_ID(type);
+		zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data));
+		ZEND_ASSERT(param_id < called_scope->num_parent_generic_args);
+		zend_type real_type = called_scope->parent_generic_args[param_id];
+		if (ZEND_TYPE_CONTAINS_CODE(real_type, Z_TYPE_P(arg))) {
+			return 1;
+		}
+		return zend_check_type_slow(
+			real_type, arg, ref, cache_slot, scope, is_return_type, is_internal);
+	}
+
 	type_mask = ZEND_TYPE_FULL_MASK(type);
 	if ((type_mask & MAY_BE_CALLABLE) && zend_is_callable(arg, IS_CALLABLE_CHECK_SILENT, NULL)) {
 		return 1;

Zend/zend_opcode.c

@@ -354,6 +354,21 @@ ZEND_API void destroy_zend_class(zval *zv)
 			if (ce->num_traits > 0) {
 				_destroy_zend_class_traits_info(ce);
 			}
+			if (ce->num_generic_params > 0) {
+				for (uint32_t i = 0; i < ce->num_generic_params; i++) {
+					zend_generic_param *param = &ce->generic_params[i];
+					zend_string_release(param->name);
+					zend_type_release(param->type, /* persistent */ 0);
+				}
+				efree(ce->generic_params);
+			}
+			if (ce->num_parent_generic_args > 0) {
+				for (uint32_t i = 0; i < ce->num_parent_generic_args; i++) {
+					zend_type *type = &ce->parent_generic_args[i];
+					zend_type_release(*type, /* persistent */ 0);
+				}
+				efree(ce->parent_generic_args);
+			}
 
 			break;
 		case ZEND_INTERNAL_CLASS:

Zend/zend_types.h

@@ -141,19 +141,20 @@ typedef struct {
 #define _ZEND_TYPE_NAME_BIT (1u << 23)
 #define _ZEND_TYPE_CE_BIT   (1u << 22)
 #define _ZEND_TYPE_LIST_BIT (1u << 21)
-#define _ZEND_TYPE_KIND_MASK (_ZEND_TYPE_LIST_BIT|_ZEND_TYPE_CE_BIT|_ZEND_TYPE_NAME_BIT)
+#define _ZEND_TYPE_CLASS_MASK (_ZEND_TYPE_LIST_BIT|_ZEND_TYPE_CE_BIT|_ZEND_TYPE_NAME_BIT)
 /* Whether the type list is arena allocated */
 #define _ZEND_TYPE_ARENA_BIT (1u << 20)
+#define _ZEND_TYPE_GENERIC_PARAM_BIT (1u << 19)
 /* Type mask excluding the flags above. */
-#define _ZEND_TYPE_MAY_BE_MASK ((1u << 20) - 1)
+#define _ZEND_TYPE_MAY_BE_MASK ((1u << 19) - 1)
 /* Must have same value as MAY_BE_NULL */
 #define _ZEND_TYPE_NULLABLE_BIT 0x2
 
 #define ZEND_TYPE_IS_SET(t) \
 	(((t).type_mask & _ZEND_TYPE_MASK) != 0)
 
 #define ZEND_TYPE_HAS_CLASS(t) \
-	((((t).type_mask) & _ZEND_TYPE_KIND_MASK) != 0)
+	((((t).type_mask) & _ZEND_TYPE_CLASS_MASK) != 0)
 
 #define ZEND_TYPE_HAS_CE(t) \
 	((((t).type_mask) & _ZEND_TYPE_CE_BIT) != 0)
@@ -164,6 +165,9 @@ typedef struct {
 #define ZEND_TYPE_HAS_LIST(t) \
 	((((t).type_mask) & _ZEND_TYPE_LIST_BIT) != 0)
 
+#define ZEND_TYPE_HAS_GENERIC_PARAM(t) \
+	((((t).type_mask) & _ZEND_TYPE_GENERIC_PARAM_BIT) != 0)
+
 #define ZEND_TYPE_USES_ARENA(t) \
 	((((t).type_mask) & _ZEND_TYPE_ARENA_BIT) != 0)
 
@@ -182,6 +186,9 @@ typedef struct {
 #define ZEND_TYPE_LIST(t) \
 	((zend_type_list *) (t).ptr)
 
+#define ZEND_TYPE_GENERIC_PARAM_ID(t) \
+	((uint32_t) (uintptr_t) (t).ptr)
+
 /* Type lists use the low bit to distinguish NAME and CE entries,
  * both of which may exist in the same list. */
 #define ZEND_TYPE_LIST_IS_CE(entry) \
@@ -226,7 +233,7 @@ typedef struct {
 
 #define ZEND_TYPE_SET_PTR_AND_KIND(t, _ptr, kind_bit) do { \
 	(t).ptr = (_ptr); \
-	(t).type_mask &= ~_ZEND_TYPE_KIND_MASK; \
+	(t).type_mask &= ~_ZEND_TYPE_CLASS_MASK; \
 	(t).type_mask |= (kind_bit); \
 } while (0)
 
@@ -285,6 +292,9 @@ typedef struct {
 #define ZEND_TYPE_INIT_CLASS_CONST_MASK(class_name, type_mask) \
 	ZEND_TYPE_INIT_PTR_MASK(class_name, _ZEND_TYPE_NAME_BIT | (type_mask))
 
+#define ZEND_TYPE_INIT_GENERIC_PARAM(param_id, extra_flags) \
+	{ (void *) (uintptr_t) param_id, _ZEND_TYPE_GENERIC_PARAM_BIT | (extra_flags) }
+
 typedef union _zend_value {
 	zend_long         lval;				/* long value */
 	double            dval;				/* double value */