More debugging

Author: Girgias

Zend/tests/type_declarations/dnf_types/variance/invalid_invariance1_var.phpt

@@ -0,0 +1,18 @@
+--TEST--
+Property types must be invariant
+--FILE--
+<?php
+
+interface X {}
+interface Y {}
+
+class A {
+    public (X&Y&Z)|L $prop;
+}
+class B extends A {
+    public (X&Y)|L $prop;
+}
+
+?>
+--EXPECTF--
+Fatal error: Type of B::$prop must be (X&Y&Z)|L (as in class A) in %s on line %d

Zend/zend_API.c

@@ -2757,18 +2757,32 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arg_info_toString, 0, 0, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 #ifdef ZEND_DEBUG
-static bool zend_verify_type_is_valid(zend_type type, int nesting_level, bool is_arena_alloc)
+ZEND_API bool zend_verify_type_is_valid(zend_type type, int nesting_level, bool is_arena_alloc)
 {
 	bool status = false;
 
-	if (ZEND_TYPE_HAS_LIST(type)) {
+	if (!ZEND_TYPE_IS_SET(type)) {
+		return nesting_level == 0;
+	} else if (ZEND_TYPE_IS_ONLY_MASK(type)) {
+		return true;
+	} else if (ZEND_TYPE_HAS_NAME(type)) {
+		zend_string *name = ZEND_TYPE_NAME(type);
+		if (zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_ITERABLE))) {
+			printf("iterable type should not exist at level %d\n", nesting_level);
+			return false;
+		}
+		return true;
+	} else if (ZEND_TYPE_HAS_LIST(type)) {
 		if (!ZEND_TYPE_IS_INTERSECTION(type) && !ZEND_TYPE_IS_UNION(type)) {
+			printf("Missing type list variant at level %d\n", nesting_level);
 			return false;
 		}
 		if (ZEND_TYPE_USES_ARENA(type) != is_arena_alloc) {
+			printf("Unexpected allocation type at level %d\n", nesting_level);
 			return false;
 		}
 		if (nesting_level >= 2) {
+			printf("Nesting exceeded: %d\n", nesting_level);
 			return false;
 		}
 
@@ -2779,20 +2793,11 @@ static bool zend_verify_type_is_valid(zend_type type, int nesting_level, bool is
 				return false;
 			}
 		ZEND_TYPE_LIST_FOREACH_END();
-		// status must be true
-	} else if (ZEND_TYPE_HAS_NAME(type)) {
-		zend_string *name = ZEND_TYPE_NAME(type);
-		if (zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_ITERABLE))) {
-			return false;
-		}
-		status = true;
-	} else if (!ZEND_TYPE_IS_COMPLEX(type)) {
 		return true;
 	}
+	printf("Error at level %d\n", nesting_level);
 	return status;
 }
-#elif
-#define zend_verify_type_is_valid(type, nesting_level, is_arena_alloc) true
 #endif
 
 /* registers all functions in *library_functions in the function hash */
@@ -4320,7 +4325,7 @@ ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, z
 
 		ZEND_ASSERT(
 			zend_verify_type_is_valid(type, /* nesting_level */ 0, /* is_arena_alloca */ ce->type == ZEND_USER_CLASS)
-			&& "zend_type is invalid" && ce->type
+			&& "zend_type is invalid"
 		);
 
 		if (access_type & ZEND_ACC_READONLY) {

Zend/zend_API.h

@@ -384,6 +384,13 @@ ZEND_API void zend_check_magic_method_implementation(
 		const zend_class_entry *ce, const zend_function *fptr, zend_string *lcname, int error_type);
 ZEND_API void zend_add_magic_method(zend_class_entry *ce, zend_function *fptr, zend_string *lcname);
 
+/* Type debugging utility */
+#ifdef ZEND_DEBUG
+ZEND_API bool zend_verify_type_is_valid(zend_type type, int nesting_level, bool is_arena_alloc);
+#else
+#define zend_verify_type_is_valid(type, nesting_level, is_arena_alloc) true
+#endif
+
 ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry);
 ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce);
 ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *orig_class_entry);

Zend/zend_inheritance.c

@@ -2522,9 +2522,8 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent
 			/* Assumption: only userland classes can use traits, as such the type must be arena allocated */
 			zend_type_copy_ctor(&type, /* use arena */ true, /* persistent */ false);
 			ZEND_ASSERT(
-				!ZEND_TYPE_IS_COMPLEX(type)
-				|| ZEND_TYPE_HAS_NAME(type)
-				|| (ZEND_TYPE_HAS_LIST(type) && ZEND_TYPE_USES_ARENA(type) && "Type list must be arena alloc")
+				zend_verify_type_is_valid(type, /* nesting_level */ 0, /* is_arena_alloca */ true)
+				&& "zend_type is invalid"
 			);
 			new_prop = zend_declare_typed_property(ce, prop_name, prop_value, flags, doc_comment, type);
 

Zend/zend_opcode.c

@@ -120,7 +120,7 @@ ZEND_API void zend_type_release(zend_type type, bool persistent) {
 				} ZEND_TYPE_LIST_FOREACH_END();
 				// TODO Figure out why DNF invalid_invariance1 test has a type not marked as arena allocated
 				if (!ZEND_TYPE_USES_ARENA(*list_type) && persistent) {
-				/* if (!ZEND_TYPE_USES_ARENA(*list_type)) { */
+				//if (!ZEND_TYPE_USES_ARENA(*list_type)) {
 					pefree(ZEND_TYPE_LIST(*list_type), persistent);
 				}
 			} else if (ZEND_TYPE_HAS_NAME(*list_type)) {
@@ -403,6 +403,17 @@ ZEND_API void destroy_zend_class(zval *zv)
 					if (prop_info->attributes) {
 						zend_hash_release(prop_info->attributes);
 					}
+					ZEND_ASSERT(
+						!ZEND_TYPE_IS_COMPLEX(prop_info->type)
+						|| ZEND_TYPE_HAS_NAME(prop_info->type)
+						|| (ZEND_TYPE_HAS_LIST(prop_info->type) && ZEND_TYPE_USES_ARENA(prop_info->type) && "Type list must be arena alloc")
+					);
+
+					//ZEND_ASSERT(
+						zend_verify_type_is_valid(prop_info->type, /* nesting_level */ 0, /* is_arena_alloca */ true)
+					//	&& "zend_type is invalid"
+					//);
+					;
 					zend_type_release(prop_info->type, /* persistent */ 0);
 				}
 			} ZEND_HASH_FOREACH_END();