Do not preserve BC for self/parent and always resolve when possible

Author: Girgias

Zend/tests/type_declarations/intersection_types/invalid_types/invalid_parent_type.phpt renamed to Zend/tests/type_declarations/intersection_types/invalid_types/invalid_unresolved_relative_type_parent.phpt

@@ -1,11 +1,9 @@
 --TEST--
-parent type cannot take part in an intersection type
+parent type cannot take part in an intersection type when unresolved
 --FILE--
 <?php
 
-class A {}
-
-class B extends A {
+trait T {
     public function foo(): parent&Iterator {}
 }
 

Zend/tests/type_declarations/intersection_types/invalid_types/invalid_self_type.phpt renamed to Zend/tests/type_declarations/intersection_types/invalid_types/invalid_unresolved_relative_type_self.phpt

@@ -1,9 +1,9 @@
 --TEST--
-self type cannot take part in an intersection type
+self type cannot take part in an intersection type when unresolved
 --FILE--
 <?php
 
-class A {
+trait T {
     public function foo(): self&Iterator {}
 }
 

Zend/tests/type_declarations/intersection_types/resolved_relativre_type_valid.phpt

@@ -0,0 +1,19 @@
+--TEST--
+parent type cannot take part in an intersection type
+--FILE--
+<?php
+
+class A {}
+
+class B extends A {
+    public function foo(): parent&Iterator {}
+}
+
+class C extends A {
+    public function foo(): self&Iterator {}
+}
+
+?>
+==DONE==
+--EXPECT--
+==DONE==

Zend/tests/type_declarations/union_types/redundant_types/duplicate_relative_class_parent_type.phpt

@@ -12,4 +12,4 @@ class Bar extends Foo {
 
 ?>
 --EXPECTF--
-Fatal error: Duplicate type parent is redundant in %s on line %d
+Fatal error: Duplicate type Foo is redundant in %s on line %d

Zend/tests/type_declarations/union_types/redundant_types/duplicate_relative_class_self_type.phpt

@@ -9,4 +9,4 @@ class Foo {
 
 ?>
 --EXPECTF--
-Fatal error: Duplicate type self is redundant in %s on line %d
+Fatal error: Duplicate type Foo is redundant in %s on line %d

Zend/tests/type_declarations/union_types/redundant_types/duplicate_resolved_relative_class_type_variation1.phpt

@@ -9,4 +9,4 @@ class Foo {
 
 ?>
 --EXPECTF--
-Fatal error: self resolves to Foo which is redundant in %s on line %d
+Fatal error: Duplicate type Foo is redundant in %s on line %d

Zend/tests/type_declarations/union_types/redundant_types/duplicate_resolved_relative_class_type_variation2.phpt

@@ -9,4 +9,4 @@ class Foo {
 
 ?>
 --EXPECTF--
-Fatal error: self resolves to Foo which is redundant in %s on line %d
+Fatal error: Duplicate type Foo is redundant in %s on line %d

Zend/tests/type_declarations/union_types/redundant_types/duplicate_resolved_relative_class_type_variation3.phpt

@@ -12,4 +12,4 @@ class Bar extends Foo {
 
 ?>
 --EXPECTF--
-Fatal error: parent resolves to Foo which is redundant in %s on line %d
+Fatal error: Duplicate type Foo is redundant in %s on line %d

Zend/tests/type_declarations/union_types/redundant_types/duplicate_resolved_relative_class_type_variation4.phpt

@@ -12,4 +12,4 @@ class Bar extends Foo {
 
 ?>
 --EXPECTF--
-Fatal error: parent resolves to Foo which is redundant in %s on line %d
+Fatal error: Duplicate type Foo is redundant in %s on line %d

Zend/zend_compile.c

@@ -1354,8 +1354,6 @@ static zend_string *add_intersection_type(zend_string *str,
 	ZEND_TYPE_LIST_FOREACH(intersection_type_list, single_type) {
 		ZEND_ASSERT(!ZEND_TYPE_HAS_LIST(*single_type));
 		ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*single_type));
-		ZEND_ASSERT(!ZEND_TYPE_IS_RELATIVE_SELF(*single_type) && "Compile time disallowed to have 'self' in intersection");
-		ZEND_ASSERT(!ZEND_TYPE_IS_RELATIVE_PARENT(*single_type) && "Compile time disallowed to have 'parent' in intersection");
 
 		intersection_str = add_type_string(intersection_str, ZEND_TYPE_NAME(*single_type), /* is_intersection */ true);
 	} ZEND_TYPE_LIST_FOREACH_END();
@@ -1390,29 +1388,13 @@ zend_string *zend_type_to_string_resolved(zend_type type, zend_class_entry *scop
 			ZEND_ASSERT(!ZEND_TYPE_HAS_LIST(*list_type));
 			ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*list_type));
 
-			/* We already have resolved types from compile time
-			 * Mimic unresolved types for BC with "self" and "parent" */
-			if (!scope && ZEND_TYPE_IS_RELATIVE_SELF(*list_type)) {
-				str = add_type_string(str, ZSTR_KNOWN(ZEND_STR_SELF), /* is_intersection */ false);
-			} else if (!scope && ZEND_TYPE_IS_RELATIVE_PARENT(*list_type)) {
-				str = add_type_string(str, ZSTR_KNOWN(ZEND_STR_PARENT), /* is_intersection */ false);
-			} else {
-				zend_string *name = ZEND_TYPE_NAME(*list_type);
-				zend_string *resolved = resolve_class_name(name, scope);
-				str = add_type_string(str, resolved, /* is_intersection */ false);
-				zend_string_release(resolved);
-			}
+			zend_string *name = ZEND_TYPE_NAME(*list_type);
+			zend_string *resolved = resolve_class_name(name, scope);
+			str = add_type_string(str, resolved, /* is_intersection */ false);
+			zend_string_release(resolved);
 		} ZEND_TYPE_LIST_FOREACH_END();
 	} else if (ZEND_TYPE_HAS_NAME(type)) {
-		/* We already have resolved types from compile time
-		 * Mimic unresolved types for BC with "self" and "parent" */
-		if (!scope && ZEND_TYPE_IS_RELATIVE_SELF(type)) {
-			str = ZSTR_KNOWN(ZEND_STR_SELF);
-		} else if (!scope && ZEND_TYPE_IS_RELATIVE_PARENT(type)) {
-			str = ZSTR_KNOWN(ZEND_STR_PARENT);
-		} else {
-			str = resolve_class_name(ZEND_TYPE_NAME(type), scope);
-		}
+		str = resolve_class_name(ZEND_TYPE_NAME(type), scope);
 	}
 
 	uint32_t type_mask = ZEND_TYPE_PURE_MASK(type);
@@ -6631,7 +6613,6 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 		} else {
 			const char *correct_name;
 			uint32_t fetch_type = zend_get_class_fetch_type_ast(ast);
-			uint32_t type_flags = 0;
 			zend_string *class_name = type_name;
 
 			if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) {
@@ -6642,15 +6623,13 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 
 				zend_ensure_valid_class_fetch_type(fetch_type);
 				if (fetch_type == ZEND_FETCH_CLASS_SELF) {
-					type_flags = _ZEND_TYPE_SELF_BIT;
 					/* Scope might be unknown for unbound closures and traits */
 					if (zend_is_scope_known()) {
 						class_name = CG(active_class_entry)->name;
 						ZEND_ASSERT(class_name && "must know class name when resolving self type at compile time");
 					}
 				} else {
 					ZEND_ASSERT(fetch_type == ZEND_FETCH_CLASS_PARENT);
-					type_flags = _ZEND_TYPE_PARENT_BIT;
 					/* Scope might be unknown for unbound closures and traits */
 					if (zend_is_scope_known()) {
 						class_name = CG(active_class_entry)->parent_name;
@@ -6681,7 +6660,7 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 
 			class_name = zend_new_interned_string(class_name);
 			zend_alloc_ce_cache(class_name);
-			return (zend_type) ZEND_TYPE_INIT_CLASS(class_name, /* allow null */ false, type_flags);
+			return (zend_type) ZEND_TYPE_INIT_CLASS(class_name, /* allow null */ false, 0);
 		}
 	}
 }
@@ -6763,28 +6742,7 @@ static void zend_is_type_list_redundant_by_single_type(zend_type_list *type_list
 		}
 		if (zend_string_equals_ci(ZEND_TYPE_NAME(type_list->types[i]), ZEND_TYPE_NAME(type))) {
 			zend_string *single_type_str = zend_type_to_string(type);
-			if (ZEND_TYPE_IS_RELATIVE_TYPE(type)) {
-				if ( (
-					ZEND_TYPE_FULL_MASK(type)
-					& ZEND_TYPE_FULL_MASK(type_list->types[i])
-					& (_ZEND_TYPE_RELATIVE_TYPE_MASK)) != 0
-				) {
-					zend_error_noreturn(E_COMPILE_ERROR, "Duplicate type %s is redundant", ZSTR_VAL(single_type_str));
-				}
-				/* zend_type_to_string() will return "self" or "parent" where the resolved type is stored in
-				 * ZEND_TYPE_NAME() */
-				zend_error_noreturn(E_COMPILE_ERROR, "%s resolves to %s which is redundant",
-					ZSTR_VAL(single_type_str), ZSTR_VAL(ZEND_TYPE_NAME(type))
-				);
-			} else if (ZEND_TYPE_IS_RELATIVE_TYPE(type_list->types[i])) {
-				/* zend_type_to_string() will return "self" or "parent" where the resolved type is stored in
-				 * ZEND_TYPE_NAME() */
-				zend_error_noreturn(E_COMPILE_ERROR, "%s resolves to %s which is redundant",
-					ZEND_TYPE_IS_RELATIVE_SELF(type_list->types[i]) ? "self" : "parent", ZSTR_VAL(ZEND_TYPE_NAME(type))
-				);
-			} else {
-				zend_error_noreturn(E_COMPILE_ERROR, "Duplicate type %s is redundant", ZSTR_VAL(single_type_str));
-			}
+			zend_error_noreturn(E_COMPILE_ERROR, "Duplicate type %s is redundant", ZSTR_VAL(single_type_str));
 		}
 	}
 }
@@ -6880,8 +6838,6 @@ static zend_type zend_compile_typename_ex(
 					/* The first class type can be stored directly as the type ptr payload. */
 					ZEND_TYPE_SET_PTR(type, ZEND_TYPE_NAME(single_type));
 					ZEND_TYPE_FULL_MASK(type) |= _ZEND_TYPE_NAME_BIT;
-					/* Add flags indicating the named type is self/parent */
-					ZEND_TYPE_FULL_MASK(type) |= (ZEND_TYPE_FULL_MASK(single_type) & _ZEND_TYPE_RELATIVE_TYPE_MASK);
 				} else {
 					if (type_list->num_types == 0) {
 						/* Switch from single name to name list. */
@@ -6890,8 +6846,6 @@ static zend_type zend_compile_typename_ex(
 						/* Clear MAY_BE_* type flags */
 						ZEND_TYPE_FULL_MASK(type_list->types[0]) &= ~_ZEND_TYPE_MAY_BE_MASK;
 						ZEND_TYPE_SET_LIST(type, type_list);
-						/* Clear flags indicating the named type is self/parent */
-						ZEND_TYPE_FULL_MASK(type) &= ~_ZEND_TYPE_RELATIVE_TYPE_MASK;
 					}
 
 					type_list->types[type_list->num_types++] = single_type;
@@ -6953,11 +6907,10 @@ static zend_type zend_compile_typename_ex(
 				zend_string_release_ex(standard_type_str, false);
 			}
 			/* Check for "self" and "parent" too */
-			if (ZEND_TYPE_IS_RELATIVE_SELF(single_type)) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Type self cannot be part of an intersection type");
-			}
-			if (ZEND_TYPE_IS_RELATIVE_PARENT(single_type)) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Type parent cannot be part of an intersection type");
+			if (zend_string_equals_literal_ci(ZEND_TYPE_NAME(single_type), "self")
+					|| zend_string_equals_literal_ci(ZEND_TYPE_NAME(single_type), "parent")) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Type %s cannot be part of an intersection type", ZSTR_VAL(ZEND_TYPE_NAME(single_type)));
 			}
 
 			/* Add type to the type list */