Simplify registration of unresolved classes

If we have an UNRESOLVED result, simply register all classes that
occur in either of the types. I believe that's equivalent to what
we're currently doing in a more complicated way.

Author: nikic

Zend/zend_inheritance.c

@@ -225,7 +225,7 @@ static zend_always_inline void register_unresolved_class(zend_string *name) {
 	zend_hash_add_empty_element(CG(delayed_autoloads), name);
 }
 
-static zend_class_entry *lookup_class(
+static zend_class_entry *lookup_class_ex(
 		zend_class_entry *scope, zend_string *name, bool register_unresolved) {
 	zend_class_entry *ce;
 
@@ -270,6 +270,10 @@ static zend_class_entry *lookup_class(
 	return NULL;
 }
 
+static zend_class_entry *lookup_class(zend_class_entry *scope, zend_string *name) {
+	return lookup_class_ex(scope, name, /* register_unresolved */ false);
+}
+
 /* Instanceof that's safe to use on unlinked classes. */
 static bool unlinked_instanceof(zend_class_entry *ce1, zend_class_entry *ce2) {
 	if (ce1 == ce2) {
@@ -350,7 +354,7 @@ static bool zend_type_permits_self(
 	ZEND_TYPE_FOREACH(type, single_type) {
 		if (ZEND_TYPE_HAS_NAME(*single_type)) {
 			zend_string *name = resolve_class_name(scope, ZEND_TYPE_NAME(*single_type));
-			zend_class_entry *ce = lookup_class(self, name, /* register_unresolved */ 0);
+			zend_class_entry *ce = lookup_class(self, name);
 			if (ce && unlinked_instanceof(self, ce)) {
 				return 1;
 			}
@@ -401,14 +405,13 @@ static void track_class_dependency(zend_class_entry *ce, zend_string *class_name
 
 static inheritance_status zend_perform_covariant_class_type_check(
 		zend_class_entry *fe_scope, zend_string *fe_class_name, zend_class_entry *fe_ce,
-		zend_class_entry *proto_scope, zend_type proto_type,
-		bool register_unresolved) {
+		zend_class_entry *proto_scope, zend_type proto_type) {
 	bool have_unresolved = 0;
 	if (ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_OBJECT) {
 		/* Currently, any class name would be allowed here. We still perform a class lookup
 		 * for forward-compatibility reasons, as we may have named types in the future that
 		 * are not classes (such as enums or typedefs). */
-		if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
+		if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
 		if (!fe_ce) {
 			have_unresolved = 1;
 		} else {
@@ -417,7 +420,7 @@ static inheritance_status zend_perform_covariant_class_type_check(
 		}
 	}
 	if (ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_ITERABLE) {
-		if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
+		if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
 		if (!fe_ce) {
 			have_unresolved = 1;
 		} else if (unlinked_instanceof(fe_ce, zend_ce_traversable)) {
@@ -437,11 +440,10 @@ static inheritance_status zend_perform_covariant_class_type_check(
 				return INHERITANCE_SUCCESS;
 			}
 
-			if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
-			proto_ce =
-				lookup_class(proto_scope, proto_class_name, register_unresolved);
+			if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
+			proto_ce = lookup_class(proto_scope, proto_class_name);
 		} else if (ZEND_TYPE_HAS_CE(*single_type)) {
-			if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
+			if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
 			proto_ce = ZEND_TYPE_CE(*single_type);
 		} else {
 			continue;
@@ -459,6 +461,16 @@ static inheritance_status zend_perform_covariant_class_type_check(
 	return have_unresolved ? INHERITANCE_UNRESOLVED : INHERITANCE_ERROR;
 }
 
+static void register_unresolved_classes(zend_class_entry *scope, zend_type type) {
+	zend_type *single_type;
+	ZEND_TYPE_FOREACH(type, single_type) {
+		if (ZEND_TYPE_HAS_NAME(*single_type)) {
+			zend_string *class_name = resolve_class_name(scope, ZEND_TYPE_NAME(*single_type));
+			lookup_class_ex(scope, class_name, /* register_unresolved */ true);
+		}
+	} ZEND_TYPE_FOREACH_END();
+}
+
 static inheritance_status zend_perform_covariant_type_check(
 		zend_class_entry *fe_scope, zend_type fe_type,
 		zend_class_entry *proto_scope, zend_type proto_type)
@@ -516,13 +528,11 @@ static inheritance_status zend_perform_covariant_type_check(
 			zend_string *fe_class_name =
 				resolve_class_name(fe_scope, ZEND_TYPE_NAME(*single_type));
 			status = zend_perform_covariant_class_type_check(
-				fe_scope, fe_class_name, NULL,
-				proto_scope, proto_type, /* register_unresolved */ 0);
+				fe_scope, fe_class_name, NULL, proto_scope, proto_type);
 		} else if (ZEND_TYPE_HAS_CE(*single_type)) {
 			zend_class_entry *fe_ce = ZEND_TYPE_CE(*single_type);
 			status = zend_perform_covariant_class_type_check(
-				fe_scope, fe_ce->name, fe_ce,
-				proto_scope, proto_type, /* register_unresolved */ 0);
+				fe_scope, fe_ce->name, fe_ce, proto_scope, proto_type);
 		} else {
 			continue;
 		}
@@ -540,21 +550,8 @@ static inheritance_status zend_perform_covariant_type_check(
 		return INHERITANCE_SUCCESS;
 	}
 
-	/* Register all classes that may have to be resolved */
-	ZEND_TYPE_FOREACH(fe_type, single_type) {
-		if (ZEND_TYPE_HAS_NAME(*single_type)) {
-			zend_string *fe_class_name =
-				resolve_class_name(fe_scope, ZEND_TYPE_NAME(*single_type));
-			zend_perform_covariant_class_type_check(
-				fe_scope, fe_class_name, NULL,
-				proto_scope, proto_type, /* register_unresolved */ 1);
-		} else if (ZEND_TYPE_HAS_CE(*single_type)) {
-			zend_class_entry *fe_ce = ZEND_TYPE_CE(*single_type);
-			zend_perform_covariant_class_type_check(
-				fe_scope, fe_ce->name, fe_ce,
-				proto_scope, proto_type, /* register_unresolved */ 1);
-		}
-	} ZEND_TYPE_FOREACH_END();
+	register_unresolved_classes(fe_scope, fe_type);
+	register_unresolved_classes(proto_scope, proto_type);
 	return INHERITANCE_UNRESOLVED;
 }