Add checks for redundant types

Author: Girgias

Zend/tests/type_declarations/dnf_types/redundant_types/duplicate_identical_intersection.phpt

@@ -0,0 +1,10 @@
+--TEST--
+Duplicate identical intersection type
+--FILE--
+<?php
+
+function foo(): (A&B)|(A&B) {}
+
+?>
+--EXPECTF--
+Fatal error: Type A&B is redundant with A&B in %s on line %d

Zend/tests/type_declarations/dnf_types/redundant_types/intersection_redundant_intersection1.phpt

@@ -0,0 +1,10 @@
+--TEST--
+Intersection type is redudant with another intersection type: prior
+--FILE--
+<?php
+
+function foo(): (A&B&C)|(A&B) {}
+
+?>
+--EXPECTF--
+Fatal error: Type A&B&C is redundant with A&B in %s on line %d

Zend/tests/type_declarations/dnf_types/redundant_types/intersection_redundant_intersection2.phpt

@@ -0,0 +1,10 @@
+--TEST--
+Intersection type is redudant with another intersection type: after
+--FILE--
+<?php
+
+function foo(): (A&B)|(A&B&C) {}
+
+?>
+--EXPECTF--
+Fatal error: Type A&B&C is redundant with A&B in %s on line %d

Zend/tests/type_declarations/dnf_types/redundant_types/type_part_intersection_as_single1.phpt

@@ -0,0 +1,11 @@
+--TEST--
+Single type is present in intersection of DNF: prior
+--FILE--
+<?php
+
+function test(): Foo|(A&Foo) {
+}
+
+?>
+--EXPECTF--
+Fatal error: Type A&Foo is redundant with Foo in %s on line %d

Zend/tests/type_declarations/dnf_types/redundant_types/type_part_intersection_as_single2.phpt

@@ -0,0 +1,11 @@
+--TEST--
+Single type is present in intersection of DNF: after
+--FILE--
+<?php
+
+function test(): (A&Foo)|Foo {
+}
+
+?>
+--EXPECTF--
+Fatal error: Type A&Foo is redundant with Foo in %s on line %d

Zend/zend_compile.c

@@ -6218,6 +6218,44 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 	}
 }
 
+static void zend_is_intersection_redundant_with_intersection(const zend_type a, const zend_type b)
+{
+	zend_type outer;
+	zend_type inner;
+	zend_type *single_outer;
+	zend_type *single_inner;
+
+	if (ZEND_TYPE_LIST(b)->num_types < ZEND_TYPE_LIST(a)->num_types) {
+		outer = b;
+		inner = a;
+	} else {
+		outer = a;
+		inner = b;
+	}
+
+	/* As outer is the intersection type with the least number of types,
+	 * it means that it is only redundant if all types of it are found in inner */
+	ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(outer), single_outer) {
+		bool is_found = false;
+		ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(inner), single_inner) {
+			if (zend_string_equals_ci(ZEND_TYPE_NAME(*single_outer), ZEND_TYPE_NAME(*single_inner))) {
+				is_found = true;
+				break;
+			}
+		} ZEND_TYPE_LIST_FOREACH_END();
+		/* Type not found in inner, thus cannot be redundant */
+		if (!is_found) {
+			return;
+		}
+	} ZEND_TYPE_LIST_FOREACH_END();
+
+	/* Type is redundant */
+	zend_string *inner_type_str = zend_type_to_string(inner);
+	zend_string *outer_type_str = zend_type_to_string(outer);
+	zend_error_noreturn(E_COMPILE_ERROR,
+		"Type %s is redundant with %s", ZSTR_VAL(inner_type_str), ZSTR_VAL(outer_type_str));
+}
+
 static zend_type zend_compile_typename(
 		zend_ast *ast, bool force_allow_null) /* {{{ */
 {
@@ -6258,7 +6296,28 @@ static zend_type zend_compile_typename(
 
 				type_list->types[type_list->num_types++] = single_type;
 
-				/* TODO Check for trivially redundant class types? */
+				/* Check for trivially redundant class types */
+				zend_type *individual_intersection_type;
+				for (size_t i = 0; i < type_list->num_types - 1; i++) {
+					if (ZEND_TYPE_HAS_LIST(type_list->types[i])) {
+						ZEND_ASSERT(ZEND_TYPE_IS_INTERSECTION(type_list->types[i]));
+						zend_is_intersection_redundant_with_intersection(single_type, type_list->types[i]);
+						continue;
+					}
+					ZEND_ASSERT(ZEND_TYPE_HAS_NAME(type_list->types[i]));
+
+					ZEND_TYPE_FOREACH(single_type, individual_intersection_type) {
+						ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*individual_intersection_type));
+						if (zend_string_equals_ci( ZEND_TYPE_NAME(type_list->types[i]),
+							ZEND_TYPE_NAME(*individual_intersection_type))) {
+							zend_string *single_type_str = zend_type_to_string(single_type);
+							zend_string *duplicate_type_str = zend_type_to_string(*individual_intersection_type);
+							zend_error_noreturn(E_COMPILE_ERROR,
+								"Type %s is redundant with %s", ZSTR_VAL(single_type_str),
+								ZSTR_VAL(duplicate_type_str));
+						}
+					} ZEND_TYPE_FOREACH_END();
+				}
 				continue;
 			}
 
@@ -6298,6 +6357,18 @@ static zend_type zend_compile_typename(
 					/* Check for trivially redundant class types */
 					for (size_t i = 0; i < type_list->num_types - 1; i++) {
 						if (ZEND_TYPE_IS_INTERSECTION(type_list->types[i])) {
+							zend_type *individual_intersection_type;
+							ZEND_TYPE_FOREACH(type_list->types[i], individual_intersection_type) {
+								ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*individual_intersection_type));
+								if (zend_string_equals_ci(ZEND_TYPE_NAME(single_type),
+										ZEND_TYPE_NAME(*individual_intersection_type))) {
+									zend_string *single_type_str = zend_type_to_string(single_type);
+									zend_string *intersection_str = zend_type_to_string(type_list->types[i]);
+									zend_error_noreturn(E_COMPILE_ERROR,
+										"Type %s is redundant with %s", ZSTR_VAL(intersection_str),
+										ZSTR_VAL(single_type_str));
+								}
+							} ZEND_TYPE_FOREACH_END();
 							continue;
 						}
 						if (zend_string_equals_ci(