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);
@@ -6659,7 +6641,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) {
@@ -6670,15 +6651,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;
@@ -6709,7 +6688,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);
 		}
 	}
 }
@@ -6791,28 +6770,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));
 		}
 	}
 }
@@ -6908,8 +6866,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. */
@@ -6918,8 +6874,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;
@@ -6981,11 +6935,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 */

Zend/zend_inheritance.c

@@ -1955,10 +1955,10 @@ static inline bool zend_was_type_resolved(zend_type original_type, zend_type res
 static zend_type zend_resolve_name_type(zend_type type, const zend_class_entry *const ce)
 {
 	ZEND_ASSERT(ZEND_TYPE_HAS_NAME(type));
-	if (ZEND_TYPE_IS_RELATIVE_SELF(type)) {
+	if (zend_string_equals_literal_ci(ZEND_TYPE_NAME(type), "self")) {
 		zend_type resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(zend_string_copy(ce->name), /* allows_null */ false, /* extra_flags */ ZEND_TYPE_FULL_MASK(type));
 		return resolved_type;
-	} else if (ZEND_TYPE_IS_RELATIVE_PARENT(type)) {
+	} else if (zend_string_equals_literal_ci(ZEND_TYPE_NAME(type), "parent")) {
 		if (!ce->parent) {
 			zend_error_noreturn(E_COMPILE_ERROR,
 				"Cannot use trait which has \"parent\" as a type when current class scope has no parent");

Zend/zend_types.h

@@ -142,12 +142,8 @@ typedef struct {
 	zend_type types[1];
 } zend_type_list;
 
-#define _ZEND_TYPE_EXTRA_FLAGS_SHIFT 27
-#define _ZEND_TYPE_MASK ((1u << 27) - 1)
-/* Only one of these bits may be set. */
-#define _ZEND_TYPE_PARENT_BIT (1u << 26)
-#define _ZEND_TYPE_SELF_BIT (1u << 25)
-#define _ZEND_TYPE_RELATIVE_TYPE_MASK (_ZEND_TYPE_SELF_BIT|_ZEND_TYPE_PARENT_BIT)
+#define _ZEND_TYPE_EXTRA_FLAGS_SHIFT 25
+#define _ZEND_TYPE_MASK ((1u << 25) - 1)
 /* Only one of these bits may be set. */
 #define _ZEND_TYPE_NAME_BIT (1u << 24)
 // Used to signify that type.ptr is not a `zend_string*` but a `const char*`,
@@ -170,17 +166,6 @@ typedef struct {
 #define ZEND_TYPE_IS_SET(t) \
 	(((t).type_mask & _ZEND_TYPE_MASK) != 0)
 
-
-/* To determine if the type resolved type was written with "self" or "parent" */
-#define ZEND_TYPE_IS_RELATIVE_TYPE(t) \
-	((((t).type_mask) & _ZEND_TYPE_RELATIVE_TYPE_MASK) != 0)
-/* To determine if the type resolved type was written with "self" */
-#define ZEND_TYPE_IS_RELATIVE_SELF(t) \
-	((((t).type_mask) & _ZEND_TYPE_SELF_BIT) != 0)
-/* To determine if the type resolved type was written with "parent" */
-#define ZEND_TYPE_IS_RELATIVE_PARENT(t) \
-	((((t).type_mask) & _ZEND_TYPE_PARENT_BIT) != 0)
-
 /* If a type is complex it means it's either a list with a union or intersection,
  * or the void pointer is a class name */
 #define ZEND_TYPE_IS_COMPLEX(t) \

ext/reflection/php_reflection.c

@@ -1397,7 +1397,10 @@ static reflection_type_kind get_type_kind(zend_type type) {
 		}
 
 		ZEND_ASSERT(ZEND_TYPE_HAS_NAME(type));
-		if (ZEND_TYPE_IS_RELATIVE_TYPE(type)) {
+		if (
+			zend_string_equals_literal_ci(ZEND_TYPE_NAME(type), "self")
+			|| zend_string_equals_literal_ci(ZEND_TYPE_NAME(type), "parent")
+		) {
 			return RELATIVE_TYPE;
 		}
 		return NAMED_TYPE;
@@ -2717,14 +2720,15 @@ ZEND_METHOD(ReflectionParameter, getClass)
 		 * TODO: Think about moving these checks to the compiler or some sort of
 		 * lint-mode.
 		 */
-		if (ZEND_TYPE_IS_RELATIVE_SELF(param->arg_info->type)) {
+		zend_string *class_name = ZEND_TYPE_NAME(param->arg_info->type);
+		if (zend_string_equals_literal_ci(class_name, "self")) {
 			ce = param->fptr->common.scope;
 			if (!ce) {
 				zend_throw_exception_ex(reflection_exception_ptr, 0,
 					"Parameter uses \"self\" as type but function is not a class member");
 				RETURN_THROWS();
 			}
-		} else if (ZEND_TYPE_IS_RELATIVE_PARENT(param->arg_info->type)) {
+		} else if (zend_string_equals_literal_ci(class_name, "parent")) {
 			ce = param->fptr->common.scope;
 			if (!ce) {
 				zend_throw_exception_ex(reflection_exception_ptr, 0,
@@ -2738,7 +2742,6 @@ ZEND_METHOD(ReflectionParameter, getClass)
 			}
 			ce = ce->parent;
 		} else {
-			zend_string *class_name = ZEND_TYPE_NAME(param->arg_info->type);
 			ce = zend_lookup_class(class_name);
 			if (!ce) {
 				zend_throw_exception_ex(reflection_exception_ptr, 0,
@@ -3186,11 +3189,11 @@ ZEND_METHOD(ReflectionRelativeClassType, resolveToNamedType)
 				"Cannot resolve \"static\" type of an interface");
 			RETURN_THROWS();
 		}
-		resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(intern->ce->name, allows_null, /*extra flags */ 0);
+		resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(intern->ce->name, allows_null, /* extra flags */ 0);
 	} else {
-		ZEND_ASSERT(ZEND_TYPE_IS_RELATIVE_TYPE(param->type));
+		ZEND_ASSERT(zend_string_equals_literal_ci(ZEND_TYPE_NAME(param->type), "self") || zend_string_equals_literal_ci(ZEND_TYPE_NAME(param->type), "parent"));
 		ZEND_ASSERT(ZEND_TYPE_HAS_NAME(param->type));
-		resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(ZEND_TYPE_NAME(param->type), allows_null, /*extra flags */ 0);
+		resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(ZEND_TYPE_NAME(param->type), allows_null, /* extra flags */ 0);
 	}
 
 	reflection_type_factory(resolved_type, return_value, /* legacy_behavior */ true, intern->ce);
@@ -3232,14 +3235,7 @@ ZEND_METHOD(ReflectionUnionType, getTypes)
 		} ZEND_TYPE_LIST_FOREACH_END();
 	} else if (ZEND_TYPE_HAS_NAME(param->type)) {
 		zend_string *name = ZEND_TYPE_NAME(param->type);
-		uint32_t type_flags = 0;
-		if (ZEND_TYPE_IS_RELATIVE_SELF(param->type)) {
-			type_flags = _ZEND_TYPE_SELF_BIT;
-		}
-		if (ZEND_TYPE_IS_RELATIVE_PARENT(param->type)) {
-			type_flags = _ZEND_TYPE_PARENT_BIT;
-		}
-		append_type(return_value, (zend_type) ZEND_TYPE_INIT_CLASS(name, /* allow_null */ false, /* extra flags */ type_flags), /* object_ce */ intern->ce);
+		append_type(return_value, (zend_type) ZEND_TYPE_INIT_CLASS(name, /* allow_null */ false, /* extra flags */ 0), /* object_ce */ intern->ce);
 	}
 
 	type_mask = ZEND_TYPE_PURE_MASK(param->type);

ext/reflection/tests/bug80190.phpt

@@ -47,14 +47,14 @@ foreach ((new ReflectionClass(C::class))->getMethods() as $method) {
 ?>
 --EXPECT--
 C::a()
-    $method->getReturnType() returns ReflectionRelativeClassType
-    $method->getReturnType()->__toString() returns self
+    $method->getReturnType() returns ReflectionNamedType
+    $method->getReturnType()->__toString() returns C
 
 C::b()
     $method->getReturnType() returns ReflectionUnionType
-    $method->getReturnType()->__toString() returns stdClass|self
+    $method->getReturnType()->__toString() returns stdClass|C
     $method->getReturnType()->getTypes() returns an array with 2 element(s)
-    type(s) in union: ReflectionNamedType(stdClass), ReflectionRelativeClassType(self)
+    type(s) in union: ReflectionNamedType(stdClass), ReflectionNamedType(C)
 
 C::c()
     $method->getReturnType() returns ReflectionRelativeClassType

ext/reflection/tests/types/ReflectionType_001.phpt

@@ -166,12 +166,12 @@ string(10) "SplSubject"
 bool(true)
 bool(false)
 bool(false)
-string(4) "self"
+string(1) "c"
 ** Method 2 - parameter 0
 bool(true)
 bool(false)
 bool(false)
-string(6) "parent"
+string(8) "stdClass"
 ** Method 3 - parameter 0
 bool(true)
 bool(false)
@@ -195,12 +195,12 @@ string(3) "int"
 bool(true)
 bool(false)
 bool(false)
-string(4) "self"
+string(1) "c"
 ** Function/method return type 4
 bool(true)
 bool(false)
 bool(false)
-string(6) "parent"
+string(8) "stdClass"
 ** Function/method return type 5
 bool(true)
 bool(false)