Support noreturn types

muglug · muglug · commit d5d2d0364c59 · 2021-03-06T22:42:36.000-05:00
diff --git a/Zend/Optimizer/zend_dump.c b/Zend/Optimizer/zend_dump.c
@@ -471,6 +471,9 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block
 			case IS_VOID:
 				fprintf(stderr, " (void)");
 				break;
+			case IS_NORETURN:
+				fprintf(stderr, " (noreturn)");
+				break;
 			default:
 				fprintf(stderr, " (\?\?\?)");
 				break;
diff --git a/Zend/tests/return_types/noreturn_allowed.phpt b/Zend/tests/return_types/noreturn_allowed.phpt
@@ -0,0 +1,29 @@
+--TEST--
+noreturn return type: acceptable cases
+--FILE--
+<?php
+
+function foo(): noreturn {
+    throw new Exception('bad');
+}
+
+try {
+    foo();
+} catch (Exception $e) {
+    // do nothing
+}
+
+function calls_foo(): noreturn {
+    foo();
+}
+
+try {
+    calls_foo();
+} catch (Exception $e) {
+    // do nothing
+}
+
+echo "OK!", PHP_EOL;
+?>
+--EXPECT--
+OK!
diff --git a/Zend/tests/return_types/noreturn_disallowed1.phpt b/Zend/tests/return_types/noreturn_disallowed1.phpt
@@ -0,0 +1,13 @@
+--TEST--
+noreturn return type: unacceptable cases: any return
+--FILE--
+<?php
+
+function foo(): noreturn {
+    return "hello"; // not permitted in a noreturn function
+}
+
+// Note the lack of function call: function validated at compile-time
+?>
+--EXPECTF--
+Fatal error: A noreturn function must not return in %s on line %d
diff --git a/Zend/tests/return_types/noreturn_disallowed2.phpt b/Zend/tests/return_types/noreturn_disallowed2.phpt
@@ -0,0 +1,13 @@
+--TEST--
+noreturn return type: unacceptable cases: empty return
+--FILE--
+<?php
+
+function foo(): noreturn {
+    return; // not permitted in a noreturn function
+}
+
+// Note the lack of function call: function validated at compile-time
+?>
+--EXPECTF--
+Fatal error: A noreturn function must not return in %s on line %d
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
@@ -174,6 +174,7 @@ static const struct reserved_class_name reserved_class_names[] = {
 	{ZEND_STRL("string")},
 	{ZEND_STRL("true")},
 	{ZEND_STRL("void")},
+	{ZEND_STRL("noreturn")},
 	{ZEND_STRL("iterable")},
 	{ZEND_STRL("object")},
 	{ZEND_STRL("mixed")},
@@ -223,6 +224,7 @@ static const builtin_type_info builtin_types[] = {
 	{ZEND_STRL("string"), IS_STRING},
 	{ZEND_STRL("bool"), _IS_BOOL},
 	{ZEND_STRL("void"), IS_VOID},
+	{ZEND_STRL("noreturn"), IS_NORETURN},
 	{ZEND_STRL("iterable"), IS_ITERABLE},
 	{ZEND_STRL("object"), IS_OBJECT},
 	{ZEND_STRL("mixed"), IS_MIXED},
@@ -2447,6 +2449,18 @@ static void zend_emit_return_type_check(
 			return;
 		}
 
+		/* `return` is illegal in a noreturn function */
+		if (ZEND_TYPE_CONTAINS_CODE(type, IS_NORETURN)) {
+			if (implicit) {
+				/* add run-time check in case we do end up returning */
+				zend_emit_op(NULL, ZEND_VERIFY_NORETURN_TYPE, expr, NULL);
+			} else {
+				zend_error_noreturn(E_COMPILE_ERROR, "A noreturn function must not return");
+			}
+
+			return;
+		}
+
 		if (!expr && !implicit) {
 			if (ZEND_TYPE_ALLOW_NULL(type)) {
 				zend_error_noreturn(E_COMPILE_ERROR,
@@ -6321,6 +6335,10 @@ static zend_type zend_compile_typename(
 		zend_error_noreturn(E_COMPILE_ERROR, "Void can only be used as a standalone type");
 	}
 
+	if ((type_mask & MAY_BE_NORETURN) && (ZEND_TYPE_HAS_CLASS(type) || type_mask != MAY_BE_NORETURN)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "noreturn can only be used as a standalone type");
+	}
+
 	if ((type_mask & (MAY_BE_NULL|MAY_BE_FALSE))
 			&& !ZEND_TYPE_HAS_CLASS(type) && !(type_mask & ~(MAY_BE_NULL|MAY_BE_FALSE))) {
 		if (type_mask == MAY_BE_NULL) {
@@ -6568,6 +6586,10 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32_t fall
 				zend_error_noreturn(E_COMPILE_ERROR, "void cannot be used as a parameter type");
 			}
 
+			if (ZEND_TYPE_FULL_MASK(arg_info->type) & MAY_BE_NORETURN) {
+				zend_error_noreturn(E_COMPILE_ERROR, "noreturn cannot be used as a parameter type");
+			}
+
 			if (default_type != IS_UNDEF && default_type != IS_CONSTANT_AST && !force_nullable
 					&& !zend_is_valid_default_value(arg_info->type, &default_node.u.constant)) {
 				zend_string *type_str = zend_type_to_string(arg_info->type);
@@ -7159,7 +7181,7 @@ void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags, z
 		if (type_ast) {
 			type = zend_compile_typename(type_ast, /* force_allow_null */ 0);
 
-			if (ZEND_TYPE_FULL_MASK(type) & (MAY_BE_VOID|MAY_BE_CALLABLE)) {
+			if (ZEND_TYPE_FULL_MASK(type) & (MAY_BE_VOID|MAY_BE_NORETURN|MAY_BE_CALLABLE)) {
 				zend_string *str = zend_type_to_string(type);
 				zend_error_noreturn(E_COMPILE_ERROR,
 					"Property %s::$%s cannot have type %s",
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
@@ -1232,6 +1232,22 @@ ZEND_API ZEND_COLD void zend_verify_return_error(const zend_function *zf, zval *
 	zend_string_release(need_msg);
 }
 
+ZEND_API ZEND_COLD void zend_verify_noreturn_error(const zend_function *zf)
+{
+	const zend_arg_info *arg_info = &zf->common.arg_info[-1];
+	const char *fname, *fsep, *fclass;
+	zend_string *need_msg;
+	const char *given_msg;
+
+	zend_verify_type_error_common(
+		zf, arg_info, NULL, &fname, &fsep, &fclass, &need_msg, &given_msg);
+
+	zend_type_error("%s%s%s(): Nothing was expected to be returned",
+		fclass, fsep, fname);
+
+	zend_string_release(need_msg);
+}
+
 #if ZEND_DEBUG
 static ZEND_COLD void zend_verify_internal_return_error(const zend_function *zf, zval *value)
 {
diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
@@ -73,6 +73,8 @@ ZEND_API ZEND_COLD void zend_verify_arg_error(
 		const zend_function *zf, const zend_arg_info *arg_info, int arg_num, zval *value);
 ZEND_API ZEND_COLD void zend_verify_return_error(
 		const zend_function *zf, zval *value);
+ZEND_API ZEND_COLD void zend_verify_noreturn_error(
+		const zend_function *zf);
 ZEND_API bool zend_verify_ref_array_assignable(zend_reference *ref);
 ZEND_API bool zend_value_instanceof_static(zval *zv);
 
diff --git a/Zend/zend_type_info.h b/Zend/zend_type_info.h
@@ -40,6 +40,7 @@
 #define MAY_BE_CALLABLE             (1 << IS_CALLABLE)
 #define MAY_BE_ITERABLE             (1 << IS_ITERABLE)
 #define MAY_BE_VOID                 (1 << IS_VOID)
+#define MAY_BE_NORETURN             (1 << IS_NORETURN)
 #define MAY_BE_STATIC               (1 << IS_STATIC)
 
 #define MAY_BE_ARRAY_SHIFT          (IS_REFERENCE)
diff --git a/Zend/zend_types.h b/Zend/zend_types.h
@@ -550,6 +550,7 @@ struct _zend_ast_ref {
 #define IS_VOID						14
 #define IS_STATIC					15
 #define IS_MIXED					16
+#define IS_NORETURN					17
 
 /* internal types */
 #define IS_INDIRECT             	12
@@ -558,8 +559,8 @@ struct _zend_ast_ref {
 #define _IS_ERROR					15
 
 /* used for casts */
-#define _IS_BOOL					17
-#define _IS_NUMBER					18
+#define _IS_BOOL					18
+#define _IS_NUMBER					19
 
 static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 	return pz->u1.v.type;
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -4237,6 +4237,15 @@ ZEND_VM_COLD_CONST_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV
 	}
 }
 
+ZEND_VM_COLD_CONST_HANDLER(200, ZEND_VERIFY_NORETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED|CACHE_SLOT)
+{
+	if (OP1_TYPE != IS_UNUSED) {
+		SAVE_OPLINE();
+		zend_verify_noreturn_error(EX(func));
+		HANDLE_EXCEPTION();
+	}
+}
+
 ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY, SPEC(OBSERVER))
 {
 	USE_OPLINE
diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
@@ -22,7 +22,7 @@
 #include <zend.h>
 #include <zend_vm_opcodes.h>
 
-static const char *zend_vm_opcodes_names[201] = {
+static const char *zend_vm_opcodes_names[202] = {
 	"ZEND_NOP",
 	"ZEND_ADD",
 	"ZEND_SUB",
@@ -224,6 +224,7 @@ static const char *zend_vm_opcodes_names[201] = {
 	"ZEND_JMP_NULL",
 	"ZEND_CHECK_UNDEF_ARGS",
 	"ZEND_FETCH_GLOBALS",
+	"ZEND_VERIFY_NORETURN_TYPE",
 };
 
 static uint32_t zend_vm_opcodes_flags[201] = {
diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
@@ -283,7 +283,8 @@ END_EXTERN_C()
 #define ZEND_JMP_NULL                   198
 #define ZEND_CHECK_UNDEF_ARGS           199
 #define ZEND_FETCH_GLOBALS              200
+#define ZEND_VERIFY_NORETURN_TYPE       201
 
-#define ZEND_VM_LAST_OPCODE             200
+#define ZEND_VM_LAST_OPCODE             201
 
 #endif
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
@@ -2971,6 +2971,7 @@ ZEND_METHOD(ReflectionUnionType, getTypes)
 
 	type_mask = ZEND_TYPE_PURE_MASK(param->type);
 	ZEND_ASSERT(!(type_mask & MAY_BE_VOID));
+	ZEND_ASSERT(!(type_mask & MAY_BE_NORETURN));
 	if (type_mask & MAY_BE_STATIC) {
 		append_type_mask(return_value, MAY_BE_STATIC);
 	}

Original file line number	Diff line number	Diff line change
`@@ -4237,6 +4237,15 @@ ZEND_VM_COLD_CONST_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST\|TMP\|VAR\|UNUSED\|CV`
`4237`	`4237`	`}`
`4238`	`4238`	`}`
`4239`	`4239`
	`4240`	`+ZEND_VM_COLD_CONST_HANDLER(200, ZEND_VERIFY_NORETURN_TYPE, CONST\|TMP\|VAR\|UNUSED\|CV, UNUSED\|CACHE_SLOT)`
	`4241`	`+{`
	`4242`	`+ if (OP1_TYPE != IS_UNUSED) {`
	`4243`	`+ SAVE_OPLINE();`
	`4244`	`+ zend_verify_noreturn_error(EX(func));`
	`4245`	`+ HANDLE_EXCEPTION();`
	`4246`	`+ }`
	`4247`	`+}`
	`4248`	`+`
`4240`	`4249`	`ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST\|TMP\|VAR\|CV, ANY, SPEC(OBSERVER))`
`4241`	`4250`	`{`
`4242`	`4251`	`USE_OPLINE`