Add static return type

Author: nikic

Zend/tests/type_declarations/static_type_param.phpt

@@ -0,0 +1,15 @@
+--TEST--
+Static type is not allowed in parameters
+--FILE--
+<?php
+
+// TODO: We could prohibit this case in the compiler instead.
+
+class Test {
+    public function test(static $param) {
+    }
+}
+
+?>
+--EXPECTF--
+Parse error: syntax error, unexpected 'static' (T_STATIC), expecting variable (T_VARIABLE) in %s on line %d

Zend/tests/type_declarations/static_type_property.phpt

@@ -0,0 +1,13 @@
+--TEST--
+Static type is not allowed in properties
+--FILE--
+<?php
+
+// Testing ?static here, to avoid ambiguity with static properties.
+class Test {
+    public ?static $foo;
+}
+
+?>
+--EXPECTF--
+Parse error: syntax error, unexpected 'static' (T_STATIC) in %s on line %d

Zend/tests/type_declarations/static_type_return.phpt

@@ -0,0 +1,73 @@
+--TEST--
+Static return type
+--FILE--
+<?php
+
+class A {
+    public function test1(): static {
+        return new static;
+    }
+    public function test2(): static {
+        return new self;
+    }
+    public function test3(): static {
+        return new static;
+    }
+    public function test4(): static|array {
+        return new self;
+    }
+}
+
+class B extends A {
+    public function test3(): static {
+        return new C;
+    }
+}
+
+class C extends B {}
+
+$a = new A;
+$b = new B;
+
+var_dump($a->test1());
+var_dump($b->test1());
+
+echo "\n";
+var_dump($a->test2());
+try {
+    var_dump($b->test2());
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "\n";
+var_dump($a->test3());
+var_dump($b->test3());
+
+echo "\n";
+var_dump($a->test4());
+try {
+    var_dump($b->test4());
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+object(A)#3 (0) {
+}
+object(B)#3 (0) {
+}
+
+object(A)#3 (0) {
+}
+Return value of A::test2() must be an instance of static, instance of A returned
+
+object(A)#3 (0) {
+}
+object(C)#3 (0) {
+}
+
+object(A)#3 (0) {
+}
+Return value of A::test4() must be of type static|array, instance of A returned

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

@@ -0,0 +1,12 @@
+--TEST--
+object and static are redundant
+--FILE--
+<?php
+
+class Test {
+    public function foo(): static|object {}
+}
+
+?>
+--EXPECTF--
+Fatal error: Type static|object contains both object and a class type, which is redundant in %s on line %d

Zend/tests/type_declarations/variance/static_variance_failure.phpt

@@ -0,0 +1,15 @@
+--TEST--
+Failure case for static variance: Replace static with self
+--FILE--
+<?php
+
+class A {
+    public function test(): static {}
+}
+class B extends A {
+    public function test(): self {}
+}
+
+?>
+--EXPECTF--
+Fatal error: Declaration of B::test(): B must be compatible with A::test(): static in %s on line %d

Zend/tests/type_declarations/variance/static_variance_success.phpt

@@ -0,0 +1,25 @@
+--TEST--
+Success cases for static variance
+--FILE--
+<?php
+
+class A {
+    public function test1(): self {}
+    public function test2(): B {}
+    public function test3(): object {}
+    public function test4(): X|Y|self {}
+    public function test5(): ?static {}
+}
+
+class B extends A {
+    public function test1(): static {}
+    public function test2(): static {}
+    public function test3(): static {}
+    public function test4(): X|Y|static {}
+    public function test5(): static {}
+}
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

Zend/zend_compile.c

@@ -1180,6 +1180,9 @@ zend_string *zend_type_to_string_resolved(zend_type type, zend_class_entry *scop
 	}
 
 	uint32_t type_mask = ZEND_TYPE_FULL_MASK(type);
+	if (type_mask & MAY_BE_STATIC) {
+		str = add_type_string(str, ZSTR_KNOWN(ZEND_STR_STATIC));
+	}
 	if (type_mask & MAY_BE_CALLABLE) {
 		str = add_type_string(str, ZSTR_KNOWN(ZEND_STR_CALLABLE));
 	}
@@ -5618,7 +5621,7 @@ static zend_type zend_compile_typename(
 			ZSTR_VAL(type_str));
 	}
 
-	if ((type_mask & MAY_BE_OBJECT) && ZEND_TYPE_HAS_CLASS(type)) {
+	if ((type_mask & MAY_BE_OBJECT) && (ZEND_TYPE_HAS_CLASS(type) || (type_mask & MAY_BE_STATIC))) {
 		zend_string *type_str = zend_type_to_string(type);
 		zend_error_noreturn(E_COMPILE_ERROR,
 			"Type %s contains both object and a class type, which is redundant",

Zend/zend_execute.c

@@ -714,6 +714,9 @@ static ZEND_COLD void zend_verify_type_error_common(
 			case MAY_BE_ITERABLE:
 				smart_str_appends(&str, "be iterable");
 				break;
+			case MAY_BE_STATIC:
+				smart_str_appends(&str, "be an instance of static");
+				break;
 			default:
 			{
 				/* Hack to print the type without null */
@@ -735,7 +738,9 @@ static ZEND_COLD void zend_verify_type_error_common(
 	*need_msg = smart_str_extract(&str);
 
 	if (value) {
-		if (ZEND_TYPE_HAS_CLASS(arg_info->type) && Z_TYPE_P(value) == IS_OBJECT) {
+		zend_bool has_class = ZEND_TYPE_HAS_CLASS(arg_info->type)
+			|| (ZEND_TYPE_FULL_MASK(arg_info->type) & MAY_BE_STATIC);
+		if (has_class && Z_TYPE_P(value) == IS_OBJECT) {
 			*given_msg = "instance of ";
 			*given_kind = ZSTR_VAL(Z_OBJCE_P(value)->name);
 		} else {
@@ -988,11 +993,12 @@ static zend_always_inline zend_bool i_zend_check_property_type(zend_property_inf
 		return 1;
 	}
 
-	ZEND_ASSERT(!(ZEND_TYPE_FULL_MASK(info->type) & MAY_BE_CALLABLE));
-	if ((ZEND_TYPE_FULL_MASK(info->type) & MAY_BE_ITERABLE) && zend_is_iterable(property)) {
+	uint32_t type_mask = ZEND_TYPE_FULL_MASK(info->type);
+	ZEND_ASSERT(!(type_mask & (MAY_BE_CALLABLE|MAY_BE_STATIC)));
+	if ((type_mask & MAY_BE_ITERABLE) && zend_is_iterable(property)) {
 		return 1;
 	}
-	return zend_verify_scalar_type_hint(ZEND_TYPE_FULL_MASK(info->type), property, strict, 0);
+	return zend_verify_scalar_type_hint(type_mask, property, strict, 0);
 }
 
 static zend_bool zend_always_inline i_zend_verify_property_type(zend_property_info *info, zval *property, zend_bool strict)
@@ -1024,6 +1030,19 @@ static zend_never_inline zval* zend_assign_to_typed_prop(zend_property_info *inf
 	return zend_assign_to_variable(property_val, &tmp, IS_TMP_VAR, EX_USES_STRICT_TYPES());
 }
 
+ZEND_API zend_bool zend_value_instanceof_static(zval *zv) {
+	if (Z_TYPE_P(zv) != IS_OBJECT) {
+		return 0;
+	}
+
+	zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data));
+	if (!called_scope) {
+		return 0;
+	}
+	return instanceof_function(Z_OBJCE_P(zv), called_scope);
+}
+
+
 static zend_always_inline zend_bool zend_check_type_slow(
 		zend_type type, zval *arg, zend_reference *ref, void **cache_slot, zend_class_entry *scope,
 		zend_bool is_return_type, zend_bool is_internal)
@@ -1074,6 +1093,9 @@ static zend_always_inline zend_bool zend_check_type_slow(
 	if ((type_mask & MAY_BE_ITERABLE) && zend_is_iterable(arg)) {
 		return 1;
 	}
+	if ((type_mask & MAY_BE_STATIC) && zend_value_instanceof_static(arg)) {
+		return 1;
+	}
 	if (ref && ZEND_REF_HAS_TYPE_SOURCES(ref)) {
 		/* We cannot have conversions for typed refs. */
 		return 0;
@@ -3042,7 +3064,7 @@ static zend_always_inline int i_zend_verify_type_assignable_zval(
 	}
 
 	type_mask = ZEND_TYPE_FULL_MASK(type);
-	ZEND_ASSERT(!(type_mask & MAY_BE_CALLABLE));
+	ZEND_ASSERT(!(type_mask & (MAY_BE_CALLABLE|MAY_BE_STATIC)));
 	if (type_mask & MAY_BE_ITERABLE) {
 		return zend_is_iterable(zv);
 	}

Zend/zend_execute.h

@@ -65,6 +65,8 @@ ZEND_API ZEND_COLD void zend_verify_arg_error(
 		const zend_function *zf, const zend_arg_info *arg_info,
 		int arg_num, void **cache_slot, zval *value);
 ZEND_API zend_bool zend_verify_ref_array_assignable(zend_reference *ref);
+ZEND_API zend_bool zend_value_instanceof_static(zval *zv);
+
 
 #define ZEND_REF_TYPE_SOURCES(ref) \
 	(ref)->sources

Zend/zend_inheritance.c

@@ -339,6 +339,34 @@ static zend_bool zend_type_contains_traversable(zend_type type) {
 	return 0;
 }
 
+static zend_bool zend_type_permits_self(
+		zend_type type, zend_class_entry *scope, zend_class_entry *self) {
+	if (ZEND_TYPE_FULL_MASK(type) & MAY_BE_OBJECT) {
+		return 1;
+	}
+
+	/* Any types that may satisfy self must have already been loaded at this point
+	 * (as a parent or interface), so we never need to register delayed variance obligations
+	 * for this case. */
+	if (ZEND_TYPE_HAS_LIST(type)) {
+		void *entry;
+		ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(type), entry) {
+		zend_string *name = resolve_class_name(scope, ZEND_TYPE_LIST_GET_NAME(entry));
+			zend_class_entry *ce = lookup_class(self, name, /* register_unresolved */ 0);
+			if (ce && unlinked_instanceof(self, ce)) {
+				return 1;
+			}
+		} ZEND_TYPE_LIST_FOREACH_END();
+		return 0;
+	}
+	if (ZEND_TYPE_HAS_NAME(type)) {
+		zend_string *name = resolve_class_name(scope, ZEND_TYPE_NAME(type));
+		zend_class_entry *ce = lookup_class(self, name, /* register_unresolved */ 0);
+		return ce && unlinked_instanceof(self, ce);
+	}
+	return 0;
+}
+
 /* Unresolved means that class declarations that are currently not available are needed to
  * determine whether the inheritance is valid or not. At runtime UNRESOLVED should be treated
  * as an ERROR. */
@@ -426,13 +454,22 @@ static inheritance_status zend_perform_covariant_type_check(
 	if (added_types) {
 		// TODO: Make "iterable" an alias of "array|Traversable" instead,
 		// so these special cases will be handled automatically.
-		if (added_types == MAY_BE_ITERABLE
+		if ((added_types & MAY_BE_ITERABLE)
 				&& (proto_type_mask & MAY_BE_ARRAY)
 				&& zend_type_contains_traversable(proto_type)) {
 			/* Replacing array|Traversable with iterable is okay */
-		} else if (added_types == MAY_BE_ARRAY && (proto_type_mask & MAY_BE_ITERABLE)) {
+			added_types &= ~MAY_BE_ITERABLE;
+		}
+		if ((added_types & MAY_BE_ARRAY) && (proto_type_mask & MAY_BE_ITERABLE)) {
 			/* Replacing iterable with array is okay */
-		} else {
+			added_types &= ~MAY_BE_ARRAY;
+		}
+		if ((added_types & MAY_BE_STATIC)
+				&& zend_type_permits_self(proto_type, proto_scope, fe_scope)) {
+			/* Replacing type that accepts self with static is okay */
+			added_types &= ~MAY_BE_STATIC;
+		}
+		if (added_types) {
 			/* Otherwise adding new types is illegal */
 			return INHERITANCE_ERROR;
 		}