Support invariant bound types

Author: Girgias

Diff for: 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)

Diff for: 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
+--EXPECT--
+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

Diff for: 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;

Diff for: 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);
 }
 /* }}} */
 

Diff for: 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;
 

Diff for: Zend/zend_inheritance.c

@@ -675,20 +675,40 @@ 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,
-	const zend_type *associated_type_ptr,
-	HashTable *associated_types
+	zend_class_entry *associated_type_scope,
+	const zend_type *associated_type_ptr
 ) {
 	const zend_type associated_type = *associated_type_ptr;
-	const zend_type concrete_type = *concrete_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(
+			concrete_scope, concrete_type_ptr, associated_type_scope, bound_type_ptr);
 
-	return INHERITANCE_ERROR;
+		if (sub_type_status != super_type_status) {
+			return INHERITANCE_ERROR;
+		} else {
+			return sub_type_status;
+		}
+	}
 }
 
 ZEND_API inheritance_status zend_perform_covariant_type_check(
@@ -706,9 +726,15 @@ 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_type_ptr, NULL);
+			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 */
@@ -1852,6 +1878,10 @@ static void zend_link_hooked_object_iter(zend_class_entry *ce) {
 }
 #endif
 
+static void zend_bound_associated_table_ht_dtor(zval *val) {
+	/* NO OP as we only use it to be able to refer and save pointers to zend_types */
+}
+
 ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *parent_ce, bool checked) /* {{{ */
 {
 	zend_property_info *property_info;
@@ -1895,6 +1925,14 @@ ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *par
 	ce->default_object_handlers = parent_ce->default_object_handlers;
 	ce->ce_flags |= ZEND_ACC_RESOLVED_PARENT;
 
+	// TODO Add associated_types HT for bound type checking
+	if (parent_ce->num_associated_types) {
+		printf("Hello\n");
+		HashTable *ht = emalloc(sizeof(HashTable));
+		zend_hash_init(ht, parent_ce->num_associated_types, NULL, zend_bound_associated_table_ht_dtor, false);
+		CG(bound_associated_types) = ht;
+	}
+
 	/* Inherit properties */
 	if (parent_ce->default_properties_count) {
 		zval *src, *dst, *end;
@@ -2063,6 +2101,12 @@ ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *par
 		}
 	}
 	ce->ce_flags |= parent_ce->ce_flags & (ZEND_HAS_STATIC_IN_METHODS | ZEND_ACC_HAS_TYPE_HINTS | ZEND_ACC_HAS_READONLY_PROPS | ZEND_ACC_USE_GUARDS | ZEND_ACC_NOT_SERIALIZABLE | ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES);
+
+	if (CG(bound_associated_types)) {
+		zend_hash_destroy(CG(bound_associated_types));
+		efree(CG(bound_associated_types));
+		CG(bound_associated_types) = NULL;
+	}
 }
 /* }}} */
 
@@ -2195,6 +2239,11 @@ static void do_interface_implementation(zend_class_entry *ce, zend_class_entry *
 			ZEND_INHERITANCE_RESET_CHILD_OVERRIDE;
 	}
 
+	if (iface->num_associated_types) {
+		HashTable *ht = emalloc(sizeof(HashTable));
+		zend_hash_init(ht, iface->num_associated_types, NULL, zend_bound_associated_table_ht_dtor, 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();
@@ -2216,6 +2265,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;
+	}
 }
 /* }}} */