enhance

Author: withinboredom

Zend/zend_API.c

@@ -2924,7 +2924,7 @@ static int compare_simple_types(const zend_type a, const zend_type b) {
 	if (a_has_name && b_has_name) {
 		const zend_string *a_name = ZEND_TYPE_NAME(a);
 		const zend_string *b_name = ZEND_TYPE_NAME(b);
-		const int cmp = zend_string_equals_ci(a_name, b_name);
+		const int cmp = ZSTR_VAL(a_name) - ZSTR_VAL(b_name);
 		if (cmp != 0) {
 			return cmp;
 		}
@@ -3107,7 +3107,7 @@ ZEND_API zend_type_node *zend_type_to_interned_tree(const zend_type type) {
 
 	size_t deduped_count = 0;
 	for (size_t i = 0; i < num_children; i++) {
-		if (i == 0 || compare_type_nodes(&children[i], &children[i - 1]) != 0) {
+		if (i == 0 || children[i] != children[i - 1]) {
 			children[deduped_count++] = children[i];
 		}
 	}
@@ -3117,6 +3117,7 @@ ZEND_API zend_type_node *zend_type_to_interned_tree(const zend_type type) {
 	node->compound.num_types = deduped_count;
 	node->compound.types = pemalloc(sizeof(zend_type_node *) * deduped_count, 1);
 	memcpy(node->compound.types, children, sizeof(zend_type_node *) * deduped_count);
+	pefree(children, 1);
 
 	return intern_type_node(node);
 }

Zend/zend_execute.c

@@ -1112,9 +1112,10 @@ static zend_always_inline bool zend_value_instanceof_static(zval *zv) {
 static zend_always_inline zend_class_entry *zend_fetch_ce_from_cache_slot(
 		void **cache_slot, zend_type *type)
 {
-	if (EXPECTED(HAVE_CACHE_SLOT && *cache_slot)) {
-		return (zend_class_entry *) *cache_slot;
-	}
+	// todo: work with cache_slot
+	//if (EXPECTED(HAVE_CACHE_SLOT && *cache_slot)) {
+	//	return (zend_class_entry *) *cache_slot;
+	//}
 
 	zend_string *name = ZEND_TYPE_NAME(*type);
 	zend_class_entry *ce;
@@ -1140,58 +1141,47 @@ static zend_always_inline zend_class_entry *zend_fetch_ce_from_cache_slot(
 	return ce;
 }
 
-static int zend_type_node_matches(const zend_type_node *node, zval *zv)
-{
-	switch (node->kind) {
-		case ZEND_TYPE_SIMPLE: {
-			return 2;
-		}
 
-		case ZEND_TYPE_UNION: {
-			for (uint32_t i = 0; i < node->compound.num_types; i++) {
-				if (zend_type_node_matches(node->compound.types[i], zv)) {
-					return 1;
+static bool zend_check_type_slow(
+		zend_type *type, zend_type_node *type_tree, zval *arg, zend_reference *ref, void **cache_slot,
+		bool is_return_type, bool is_internal)
+{
+	if (EXPECTED(type_tree != NULL) && type_tree->kind != ZEND_TYPE_SIMPLE) {
+		switch (type_tree->kind) {
+			case ZEND_TYPE_UNION: {
+				for (uint32_t i = 0; i < type_tree->compound.num_types; i++) {
+					if (zend_check_type_slow(type, type_tree->compound.types[i], arg, ref, cache_slot, is_return_type, is_internal)) {
+						return true;
+					}
 				}
+				return false;
 			}
-			return 0;
-		}
 
-		case ZEND_TYPE_INTERSECTION: {
-			for (uint32_t i = 0; i < node->compound.num_types; i++) {
-				if (!zend_type_node_matches(node->compound.types[i], zv)) {
-					return 0;
+			case ZEND_TYPE_INTERSECTION: {
+				for (uint32_t i = 0; i < type_tree->compound.num_types; i++) {
+					if (!zend_check_type_slow(type, type_tree->compound.types[i], arg, ref, cache_slot, is_return_type, is_internal)) {
+						return false;
+					}
 				}
+				return true;
 			}
-			return 1;
-		}
-
-		default:
-			return 0;
-	}
-}
 
-
-static zend_always_inline bool zend_check_type_slow(
-		zend_type *type, zend_type_node *type_tree, zval *arg, zend_reference *ref, void **cache_slot,
-		bool is_return_type, bool is_internal)
-{
-	if (EXPECTED(type_tree != NULL) && type_tree->kind != ZEND_TYPE_SIMPLE) {
-		const int result = zend_type_node_matches(type_tree, arg);
-		if (result < 2) {
-			return result;
+			default:
+				return false;
 		}
 	}
 
-	if (ZEND_TYPE_IS_COMPLEX(*type) && EXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) {
-		const zend_class_entry *ce = zend_fetch_ce_from_cache_slot(cache_slot, type);
+	if (ZEND_TYPE_IS_COMPLEX(type_tree->simple_type) && EXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) {
+		const zend_class_entry *ce = zend_fetch_ce_from_cache_slot(cache_slot, &type_tree->simple_type);
 		/* If we have a CE we check if it satisfies the type constraint,
 		 * otherwise it will check if a standard type satisfies it. */
 		if (ce && instanceof_function(Z_OBJCE_P(arg), ce)) {
 			return true;
 		}
+		PROGRESS_CACHE_SLOT();
 	}
 
-	const uint32_t type_mask = ZEND_TYPE_FULL_MASK(*type);
+	const uint32_t type_mask = ZEND_TYPE_FULL_MASK(type_tree->simple_type);
 	if ((type_mask & MAY_BE_CALLABLE) &&
 		zend_is_callable(arg, is_internal ? IS_CALLABLE_SUPPRESS_DEPRECATIONS : 0, NULL)) {
 		return 1;