Use a private constructor instead

Add some APIs so that we can stop relying on the get_constructor object handler

Author: Girgias

Zend/Optimizer/escape_analysis.c

@@ -167,7 +167,7 @@ static bool is_allocation_def(zend_op_array *op_array, zend_ssa *ssa, int def, i
 				 && !ce->create_object
 				 && ce->default_object_handlers->get_constructor == zend_std_get_constructor
 				 && ce->default_object_handlers->dtor_obj == zend_objects_destroy_object
-				 && (!ce->constructor || zend_is_pass_function(ce->constructor))
+				 && !ce->constructor
 				 && !ce->destructor
 				 && !ce->__get
 				 && !ce->__set
@@ -236,7 +236,7 @@ static bool is_local_def(zend_op_array *op_array, zend_ssa *ssa, int def, int va
 				 && !ce->create_object
 				 && ce->default_object_handlers->get_constructor == zend_std_get_constructor
 				 && ce->default_object_handlers->dtor_obj == zend_objects_destroy_object
-				 && (!ce->constructor || zend_is_pass_function(ce->constructor))
+				 && !ce->constructor
 				 && !ce->destructor
 				 && !ce->__get
 				 && !ce->__set

Zend/Optimizer/zend_inference.c

@@ -3393,7 +3393,7 @@ static zend_always_inline zend_result _zend_update_type_info(
 			}
 			/* New objects without constructors cannot escape. */
 			if (ce
-			 && (!ce->constructor || zend_is_pass_function(ce->constructor))
+			 && !ce->constructor
 			 && !ce->create_object
 			 && ce->default_object_handlers->get_constructor == zend_std_get_constructor) {
 				tmp &= ~MAY_BE_RCN;

Zend/tests/closures/closure_instantiate.phpt

@@ -8,14 +8,10 @@ Mark Baker mark@lange.demon.co.uk at the PHPNW2017 Conference for PHP Testfest 2
 try {
     // Closures should be instantiatable using new
     $x = new Closure();
-} catch (Exception $e) {
-    // Instantiating a closure is an error, not an exception, so we shouldn't see this
-    echo 'EXCEPTION: ', $e->getMessage();
 } catch (Throwable $e) {
-    // This is the message that we should see for a caught error
-    echo 'ERROR: ', $e->getMessage();
+    echo $e::class, ': ', $e->getMessage();
 }
 
 ?>
 --EXPECT--
-ERROR: Instantiation of class Closure is not allowed
+Error: Instantiation of class Closure is not allowed

Zend/tests/enum/no-new-through-reflection.phpt

@@ -13,4 +13,4 @@ try {
 
 ?>
 --EXPECT--
-ReflectionException: Class Foo cannot be instantiated manually
+ReflectionException: Cannot instantiate enum Foo

Zend/tests/traits/bug60173.phpt

@@ -9,7 +9,7 @@ $rc = new ReflectionClass('foo');
 $rc->newInstance();
 ?>
 --EXPECTF--
-Fatal error: Uncaught ReflectionException: Class foo cannot be instantiated manually in %s:%d
+Fatal error: Uncaught ReflectionException: Cannot instantiate trait foo in %s:%d
 Stack trace:
 #0 %s(%d): ReflectionClass->newInstance()
 #1 {main}

Zend/zend_API.c

@@ -1793,16 +1793,7 @@ ZEND_API void object_properties_load(zend_object *object, const HashTable *prope
 static zend_always_inline zend_result _object_and_properties_init(zval *arg, zend_class_entry *class_type, HashTable *properties) /* {{{ */
 {
 	if (UNEXPECTED(class_type->ce_flags & ZEND_ACC_UNINSTANTIABLE)) {
-		if (class_type->ce_flags & ZEND_ACC_INTERFACE) {
-			zend_throw_error(NULL, "Cannot instantiate interface %s", ZSTR_VAL(class_type->name));
-		} else if (class_type->ce_flags & ZEND_ACC_TRAIT) {
-			zend_throw_error(NULL, "Cannot instantiate trait %s", ZSTR_VAL(class_type->name));
-		} else if (class_type->ce_flags & ZEND_ACC_ENUM) {
-			zend_throw_error(NULL, "Cannot instantiate enum %s", ZSTR_VAL(class_type->name));
-		} else {
-			ZEND_ASSERT(class_type->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS));
-			zend_throw_error(NULL, "Cannot instantiate abstract class %s", ZSTR_VAL(class_type->name));
-		}
+		zend_cannot_instantiate_class(class_type, NULL);
 		ZVAL_NULL(arg);
 		Z_OBJ_P(arg) = NULL;
 		return FAILURE;
@@ -1846,25 +1837,7 @@ ZEND_API zend_result object_init_ex(zval *arg, zend_class_entry *class_type) /*
 
 ZEND_API zend_result object_init_with_constructor(zval *arg, zend_class_entry *class_type, uint32_t param_count, zval *params, HashTable *named_params) /* {{{ */
 {
-	zend_function *constructor = class_type->constructor;
-	if (UNEXPECTED(constructor == NULL)) {
-		const zend_attribute *non_instantiable_class = zend_get_attribute_str(class_type->attributes, ZEND_STRL("noninstantiableclass"));
-		ZEND_ASSERT(non_instantiable_class);
-		zend_string *msg = Z_STR(non_instantiable_class->args[0].value);
-		zend_throw_error(NULL, "%s", ZSTR_VAL(msg));
-		ZVAL_UNDEF(arg);
-		return FAILURE;
-	}
-
-	if (UNEXPECTED(!(constructor->common.fn_flags & ZEND_ACC_PUBLIC))) {
-		/* Use zend_bad_constructor_call() somehow? */
-		zend_throw_error(
-			NULL,
-			"Call to %s %s::%s() from global scope",
-			zend_visibility_string(class_type->constructor->common.fn_flags),
-			ZSTR_VAL(class_type->constructor->common.scope->name),
-			ZSTR_VAL(class_type->constructor->common.function_name)
-		);
+	if (UNEXPECTED(!zend_check_class_is_instantiable_or_throw(class_type, zend_get_executed_scope()))) {
 		ZVAL_UNDEF(arg);
 		return FAILURE;
 	}
@@ -1876,8 +1849,9 @@ ZEND_API zend_result object_init_with_constructor(zval *arg, zend_class_entry *c
 	}
 	zend_object *obj = Z_OBJ_P(arg);
 
-	/* Fake constructor means we don't need to call the constructor actually */
-	if (zend_is_pass_function(constructor)) {
+	zend_function *constructor = class_type->constructor;
+	/* No constructor, so no need to call it */
+	if (constructor == NULL) {
 		/* Surprisingly, this is the only case where internal classes will allow to pass extra arguments
 		 * However, if there are named arguments (and it is not empty),
 		 * an Error must be thrown to be consistent with new ClassName() */
@@ -3523,11 +3497,6 @@ static zend_class_entry *do_register_internal_class(const zend_class_entry *orig
 	if (class_entry->info.internal.builtin_functions) {
 		zend_register_functions(class_entry, class_entry->info.internal.builtin_functions, &class_entry->function_table, EG(current_module)->type);
 	}
-	
-	/* Assign the pass function as a default constructor */
-	if (class_entry->constructor == NULL) {
-		class_entry->constructor = (zend_function *) &zend_pass_function;
-	}
 
 	lowercase_name = zend_string_tolower_ex(orig_class_entry->name, EG(current_module)->type == MODULE_PERSISTENT);
 	lowercase_name = zend_new_interned_string(lowercase_name);

Zend/zend_ast.c

@@ -1058,6 +1058,10 @@ static zend_result ZEND_FASTCALL zend_ast_evaluate_inner(
 				return FAILURE;
 			}
 
+			if (!zend_is_class_instantiable(ce)) {
+				return FAILURE;
+			}
+
 			if (object_init_ex(result, ce) != SUCCESS) {
 				return FAILURE;
 			}
@@ -1096,10 +1100,9 @@ static zend_result ZEND_FASTCALL zend_ast_evaluate_inner(
 					}
 				}
 
-				zend_function *ctor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
-				if (ctor) {
+				if (ce->constructor) {
 					zend_call_known_function(
-						ctor, Z_OBJ_P(result), Z_OBJCE_P(result), NULL, 0, NULL, args);
+						ce->constructor, Z_OBJ_P(result), Z_OBJCE_P(result), NULL, 0, NULL, args);
 				}
 
 				zend_array_destroy(args);
@@ -1117,10 +1120,9 @@ static zend_result ZEND_FASTCALL zend_ast_evaluate_inner(
 					}
 				}
 
-				zend_function *ctor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
-				if (ctor) {
+				if (ce->constructor) {
 					zend_call_known_instance_method(
-						ctor, Z_OBJ_P(result), NULL, args_ast->children, args);
+						ce->constructor, Z_OBJ_P(result), NULL, args_ast->children, args);
 				}
 
 				for (uint32_t i = 0; i < args_ast->children; i++) {

Zend/zend_closures_arginfo.h

@@ -5704,7 +5704,9 @@ static void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */
 
 
 	const zend_function *fbc = NULL;
-	if (ce && ce->constructor && is_func_accessible(ce->constructor)) {
+	if (ce
+		&& ce->constructor
+		&& is_func_accessible(ce->constructor)) {
 		fbc = ce->constructor;
 	}
 
@@ -9527,6 +9529,33 @@ static void zend_compile_enum_backing_type(zend_class_entry *ce, zend_ast *enum_
 	zend_type_release(type, 0);
 }
 
+static ZEND_FUNCTION(non_instantiable_constructor)
+{
+}
+
+static zend_arg_info zend_non_instantiable_constructor_arg_info[1] = {0};
+ZEND_API const zend_internal_function zend_non_instantiable_constructor = {
+	ZEND_INTERNAL_FUNCTION, /* type */
+	{0, 0, 0},        /* arg_flags */
+	ZEND_ACC_PRIVATE,     /* fn_flags */
+	NULL,            /* name */
+	NULL,                  /* scope */
+	NULL,               /* prototype */
+	0,                  /* num_args */
+	0,            /* required_num_args */
+	zend_non_instantiable_constructor_arg_info + 1, /* arg_info */
+	NULL,               /* attributes */
+	NULL,        /* run_time_cache */
+	NULL,            /* doc_comment */
+	0,                        /* T */
+	0,                   /* fn_flags2 */
+	NULL,                /* prop_info */
+	ZEND_FN(non_instantiable_constructor), /* handler */
+	NULL,                 /* module */
+	NULL,     /* frameless_function_infos */
+	{NULL,NULL,NULL,NULL}   /* reserved */
+};
+
 static void zend_compile_class_decl(znode *result, const zend_ast *ast, bool toplevel) /* {{{ */
 {
 	const zend_ast_decl *decl = (const zend_ast_decl *) ast;
@@ -9648,11 +9677,11 @@ static void zend_compile_class_decl(znode *result, const zend_ast *ast, bool top
 		ce->ce_flags |= ZEND_ACC_TOP_LEVEL;
 	}
 
-	/* Add a default "pass" constructor if none are defined */
+	/* Add zend_non_instantiable_constructor constructor if class cannot be manually instantiated */
 	if (ce->constructor == NULL && (ce->ce_flags & (ZEND_ACC_ENUM|ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT)) == 0) {
-		zend_attribute *non_instantiable_class = zend_get_attribute_str(ce->attributes, ZEND_STRL("noninstantiableclass"));
-		if (!non_instantiable_class) {
-			ce->constructor = (zend_function *) &zend_pass_function;
+		const zend_attribute *non_instantiable_class = zend_get_attribute_str(ce->attributes, ZEND_STRL("noninstantiableclass"));
+		if (non_instantiable_class) {
+			ce->constructor = (zend_function *) &zend_non_instantiable_constructor;
 		}
 	}
 

Zend/zend_compile.c

@@ -654,11 +654,11 @@ struct _zend_execute_data {
 	zend_array          *extra_named_params;
 };
 
-/* export zend_pass_function to allow comparisons against it */
-extern ZEND_API const zend_internal_function zend_pass_function;
+/* export zend_non_instantiable_constructor to allow comparisons against it */
+extern ZEND_API const zend_internal_function zend_non_instantiable_constructor;
 
-static zend_always_inline bool zend_is_pass_function(const zend_function *fn) {
-	return fn == (const zend_function*) &zend_pass_function;
+static zend_always_inline bool zend_is_non_instantiable_constructor(const zend_function *fn) {
+	return fn == (const zend_function*) &zend_non_instantiable_constructor;
 }
 
 #define ZEND_CALL_HAS_THIS           IS_OBJECT_EX