Support invariant bound types for associated types

Author: Girgias

Zend/tests/type_declarations/associated/associated_001.phpt

@@ -8,10 +8,25 @@ interface I {
     public function foo(T $param): T;
 }
 
-class C implements I {
-    public function foo(string $param): string {}
+class CS implements I {
+    public function foo(string $param): string {
+        return $param . '!';
+    }
 }
 
+class CI implements I {
+    public function foo(int $param): int {
+        return $param + 42;
+    }
+}
+
+$cs = new CS();
+var_dump($cs->foo("Hello"));
+
+$ci = new CI();
+var_dump($ci->foo(5));
+
 ?>
---EXPECTF--
-Fatal error: Declaration of C::foo(string $param): string must be compatible with I::foo(T $param): T in %s on line %d
+--EXPECT--
+string(6) "Hello!"
+int(47)

Zend/tests/type_declarations/associated/multiple_associated_type.phpt

@@ -10,11 +10,65 @@ interface I {
     public function get(K $key): V;
 }
 
-class C implements I {
-    public function set(int $key, string $value): void {}
-    public function get(int $key): string {}
+class C1 implements I {
+    public array $a = [];
+    public function set(int $key, string $value): void {
+        $this->a[$key] = $value . '!';
+    }
+    public function get(int $key): string {
+        return $this->a[$key];
+    }
 }
 
+class C2 implements I {
+    public array $a = [];
+    public function set(string $key, object $value): void {
+        $this->a[$key] = $value;
+    }
+    public function get(string $key): object {
+        return $this->a[$key];
+    }
+}
+
+$c1 = new C1();
+$c1->set(5, "Hello");
+var_dump($c1->a);
+var_dump($c1->get(5));
+
+$c2 = new C2();
+$c2->set('C1', $c1);
+var_dump($c2->a);
+var_dump($c2->get('C1'));
+
+try {
+    $c1->set('blah', "Hello");
+} catch (\Throwable $e) {
+    echo $e::class, ': ', $e->getMessage(), PHP_EOL;
+}
+
+
 ?>
 --EXPECTF--
-Fatal error: Declaration of C::set(int $key, string $value): void must be compatible with I::set(K $key, V $value): void in %s on line %d
+array(1) {
+  [5]=>
+  string(6) "Hello!"
+}
+string(6) "Hello!"
+array(1) {
+  ["C1"]=>
+  object(C1)#1 (1) {
+    ["a"]=>
+    array(1) {
+      [5]=>
+      string(6) "Hello!"
+    }
+  }
+}
+object(C1)#1 (1) {
+  ["a"]=>
+  array(1) {
+    [5]=>
+    string(6) "Hello!"
+  }
+}
+TypeError: C1::set(): Argument #1 ($key) must be of type int, string given, called in %s on line %d

Zend/zend.c

@@ -732,6 +732,7 @@ static void compiler_globals_ctor(zend_compiler_globals *compiler_globals) /* {{
 
 	compiler_globals->script_encoding_list = NULL;
 	compiler_globals->current_linking_class = NULL;
+	compiler_globals->bound_associated_types = NULL;
 
 	/* Map region is going to be created and resized at run-time. */
 	compiler_globals->map_ptr_real_base = NULL;

Zend/zend_compile.c

@@ -463,6 +463,7 @@ void init_compiler(void) /* {{{ */
 	CG(delayed_autoloads) = NULL;
 	CG(unlinked_uses) = NULL;
 	CG(current_linking_class) = NULL;
+	CG(bound_associated_types) = NULL;
 }
 /* }}} */
 
@@ -491,6 +492,7 @@ void shutdown_compiler(void) /* {{{ */
 		CG(unlinked_uses) = NULL;
 	}
 	CG(current_linking_class) = NULL;
+	ZEND_ASSERT(CG(bound_associated_types) == NULL);
 }
 /* }}} */
 

Zend/zend_globals.h

@@ -151,6 +151,8 @@ struct _zend_compiler_globals {
 	HashTable *delayed_autoloads;
 	HashTable *unlinked_uses;
 	zend_class_entry *current_linking_class;
+	/* Those are initialized and destroyed by zend_do_inheritance_ex() */
+	HashTable *bound_associated_types;
 
 	uint32_t rtd_key_counter;
 

Zend/zend_inheritance.c

@@ -675,6 +675,42 @@ static inheritance_status zend_is_intersection_subtype_of_type(
 	return early_exit_status == INHERITANCE_ERROR ? INHERITANCE_SUCCESS : INHERITANCE_ERROR;
 }
 
+ZEND_API inheritance_status zend_perform_covariant_type_check(
+		zend_class_entry *fe_scope, const zend_type *fe_type_ptr,
+		zend_class_entry *proto_scope, const zend_type *proto_type_ptr);
+
+static inheritance_status zend_is_type_subtype_of_associated_type(
+	zend_class_entry *concrete_scope,
+	const zend_type *concrete_type_ptr,
+	zend_class_entry *associated_type_scope,
+	const zend_type *associated_type_ptr
+) {
+	const zend_type associated_type = *associated_type_ptr;
+
+	ZEND_ASSERT(CG(bound_associated_types) && "Have associated type");
+	ZEND_ASSERT(ZEND_TYPE_HAS_NAME(associated_type));
+
+	zend_string *associated_type_name = ZEND_TYPE_NAME(associated_type);
+	const zend_type *bound_type_ptr = zend_hash_find_ptr(CG(bound_associated_types), associated_type_name);
+	if (bound_type_ptr == NULL) {
+		/* Loosing const qualifier here is OK because this hashtable never frees or does anything with the value */
+		zend_hash_add_new_ptr(CG(bound_associated_types), associated_type_name, (void*)concrete_type_ptr);
+		return INHERITANCE_SUCCESS;
+	} else {
+		/* Associated type must be invariant */
+		const inheritance_status sub_type_status = zend_perform_covariant_type_check(
+			concrete_scope, concrete_type_ptr, associated_type_scope, bound_type_ptr);
+		const inheritance_status super_type_status = zend_perform_covariant_type_check(
+			associated_type_scope, bound_type_ptr, concrete_scope, concrete_type_ptr);
+
+		if (sub_type_status != super_type_status) {
+			return INHERITANCE_ERROR;
+		} else {
+			return sub_type_status;
+		}
+	}
+}
+
 ZEND_API inheritance_status zend_perform_covariant_type_check(
 		zend_class_entry *fe_scope, const zend_type *fe_type_ptr,
 		zend_class_entry *proto_scope, const zend_type *proto_type_ptr)
@@ -690,6 +726,17 @@ ZEND_API inheritance_status zend_perform_covariant_type_check(
 		return INHERITANCE_SUCCESS;
 	}
 
+	/* If we check for concrete return type */
+	if (ZEND_TYPE_IS_ASSOCIATED(proto_type)) {
+		return zend_is_type_subtype_of_associated_type(
+			fe_scope, fe_type_ptr, proto_scope, proto_type_ptr);
+	}
+	/* If we check for concrete parameter type */
+	if (ZEND_TYPE_IS_ASSOCIATED(fe_type)) {
+		return zend_is_type_subtype_of_associated_type(
+			proto_scope, proto_type_ptr, fe_scope, fe_type_ptr);
+	}
+
 	/* Builtin types may be removed, but not added */
 	uint32_t fe_type_mask = ZEND_TYPE_PURE_MASK(fe_type);
 	uint32_t proto_type_mask = ZEND_TYPE_PURE_MASK(proto_type);
@@ -2174,6 +2221,11 @@ static void do_interface_implementation(zend_class_entry *ce, zend_class_entry *
 			ZEND_INHERITANCE_RESET_CHILD_OVERRIDE;
 	}
 
+	if (iface->associated_types) {
+		HashTable *ht = emalloc(sizeof(HashTable));
+		zend_hash_init(ht, zend_hash_num_elements(iface->associated_types), NULL, NULL, false);
+		CG(bound_associated_types) = ht;
+	}
 	ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&iface->constants_table, key, c) {
 		do_inherit_iface_constant(key, c, ce, iface);
 	} ZEND_HASH_FOREACH_END();
@@ -2195,6 +2247,11 @@ static void do_interface_implementation(zend_class_entry *ce, zend_class_entry *
 	if (iface->num_interfaces) {
 		zend_do_inherit_interfaces(ce, iface);
 	}
+	if (CG(bound_associated_types)) {
+		zend_hash_destroy(CG(bound_associated_types));
+		efree(CG(bound_associated_types));
+		CG(bound_associated_types) = NULL;
+	}
 }
 /* }}} */