core: set zend_pass_function as default constructor

This is to make the semantics of when a class cannot be instiantiated obvious rather than needed to remember to call the get_constructor() handler.

For this we create a new NonInstantiableClass attribute that can be set to mark classes which shouldn't be instantiable with a message and set the constructor pointer to NULL

Author: Girgias

UPGRADING

@@ -43,6 +43,10 @@ PHP 8.6 UPGRADE NOTES
   . MessageFormatter::parse() and parseMessage() now return PHP_INT_MIN as
     int, rather than float, on 64-bit platforms when parsing integer values.
 
+- MySQLi:
+  . mysqli_fetch_object() no longer accepts classes with non-public
+    constructors.
+
 - PCNTL:
   . pcntl_alarm() now raises a ValueError if the seconds argument is
     lower than zero or greater than platform's UINT_MAX.
@@ -54,6 +58,10 @@ PHP 8.6 UPGRADE NOTES
     execution error occurs (e.g. malformed UTF-8 input with the /u modifier).
     This is consistent with other preg_* functions.
 
+- PDO:
+  . PDOStatement::fetchObject() no longer accepts classes with non-public
+    constructors.
+
 - Phar:
   . Phar::mungServer() now raises a ValueError when an invalid
     argument value is passed instead of being silently ignored.
@@ -69,13 +77,19 @@ PHP 8.6 UPGRADE NOTES
     $constructor_args argument instead of $class. Errors raised when
     the requested class is not instantiable (abstract, interface, enum)
     now surface before the row is fetched.
+  . pg_fetch_object() no longer accepts classes with non-public
+    constructors.
 
 - Posix:
   . posix_access() now raises a ValueError when an invalid $flags
     argument value is passed.
   . posix_mkfifo() now raises a ValueError when an invalid $permissions
     argument value is passed.
 
+- Reflection:
+  . ReflectionClass::newInstanceWithoutConstructor() no longer accepts
+    classes with non-public constructors.
+
 - Session:
   . Setting session.cookie_path, session.cookie_domain, or session.cache_limiter
     to a value containing null bytes now emits a warning and leaves the setting

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
+				 && (!ce->constructor || zend_is_pass_function(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
+				 && (!ce->constructor || zend_is_pass_function(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
+			 && (!ce->constructor || zend_is_pass_function(ce->constructor))
 			 && !ce->create_object
 			 && ce->default_object_handlers->get_constructor == zend_std_get_constructor) {
 				tmp &= ~MAY_BE_RCN;

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

@@ -7,10 +7,10 @@ enum Foo {}
 
 try {
     (new \ReflectionClass(Foo::class))->newInstanceWithoutConstructor();
-} catch (Error $e) {
-    echo $e->getMessage() . "\n";
+} catch (Throwable $e) {
+    echo $e::class, ': ', $e->getMessage() . "\n";
 }
 
 ?>
 --EXPECT--
-Cannot instantiate enum Foo
+ReflectionException: Class Foo cannot be instantiated manually

Zend/tests/traits/bug60173.phpt

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

Zend/zend_API.c

@@ -25,6 +25,7 @@
 #include "zend_hash.h"
 #include "zend_modules.h"
 #include "zend_extensions.h"
+#include "zend_attributes.h"
 #include "zend_constants.h"
 #include "zend_interfaces.h"
 #include "zend_exceptions.h"
@@ -1845,27 +1846,38 @@ 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)
+		);
+		ZVAL_UNDEF(arg);
+		return FAILURE;
+	}
+
 	zend_result status = _object_and_properties_init(arg, class_type, NULL);
 	if (UNEXPECTED(status == FAILURE)) {
 		ZVAL_UNDEF(arg);
 		return FAILURE;
 	}
 	zend_object *obj = Z_OBJ_P(arg);
-	zend_function *constructor = obj->handlers->get_constructor(obj);
-	if (constructor == NULL) {
-		/* The constructor can be NULL for 2 different reasons:
-		 * - It is not defined
-		 * - We are not allowed to call the constructor (e.g. private, or internal opaque class)
-		 *   and an exception has been thrown
-		 * in the former case, we are (mostly) done and the object is initialized,
-		 * in the latter we need to destroy the object as initialization failed
-		 */
-		if (UNEXPECTED(EG(exception))) {
-			zval_ptr_dtor(arg);
-			ZVAL_UNDEF(arg);
-			return FAILURE;
-		}
 
+	/* Fake constructor means we don't need to call the constructor actually */
+	if (zend_is_pass_function(constructor)) {
 		/* 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() */
@@ -1884,6 +1896,7 @@ ZEND_API zend_result object_init_with_constructor(zval *arg, zend_class_entry *c
 			return SUCCESS;
 		}
 	}
+
 	/* A constructor should not return a value, however if an exception is thrown
 	 * zend_call_known_function() will set the retval to IS_UNDEF */
 	zval retval;
@@ -3510,6 +3523,11 @@ 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_attributes.c

@@ -32,6 +32,7 @@ ZEND_API zend_class_entry *zend_ce_override;
 ZEND_API zend_class_entry *zend_ce_deprecated;
 ZEND_API zend_class_entry *zend_ce_nodiscard;
 ZEND_API zend_class_entry *zend_ce_delayed_target_validation;
+ZEND_API zend_class_entry *zend_ce_non_instantiable_class;
 
 static zend_object_handlers attributes_object_handlers_sensitive_parameter_value;
 
@@ -264,6 +265,24 @@ ZEND_METHOD(NoDiscard, __construct)
 	}
 }
 
+ZEND_METHOD(NonInstantiableClass, __construct)
+{
+	zend_string *message = NULL;
+	zval value;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_STR(message)
+	ZEND_PARSE_PARAMETERS_END();
+
+	ZVAL_STR(&value, message);
+	zend_update_property_ex(zend_ce_non_instantiable_class, Z_OBJ_P(ZEND_THIS), ZSTR_KNOWN(ZEND_STR_MESSAGE), &value);
+
+	/* The assignment might fail due to 'readonly'. */
+	if (UNEXPECTED(EG(exception))) {
+		RETURN_THROWS();
+	}
+}
+
 static zend_attribute *get_attribute(const HashTable *attributes, const zend_string *lcname, uint32_t offset)
 {
 	if (attributes) {
@@ -605,6 +624,9 @@ void zend_register_attribute_ce(void)
 
 	zend_ce_delayed_target_validation = register_class_DelayedTargetValidation();
 	attr = zend_mark_internal_attribute(zend_ce_delayed_target_validation);
+
+	zend_ce_non_instantiable_class = register_class_NonInstantiableClass();
+	attr = zend_mark_internal_attribute(zend_ce_delayed_target_validation);
 }
 
 void zend_attributes_shutdown(void)

Zend/zend_attributes.stub.php

@@ -103,3 +103,13 @@ public function __construct(?string $message = null) {}
  */
 #[Attribute(Attribute::TARGET_ALL)]
 final class DelayedTargetValidation {}
+
+/**
+ * @strict-properties
+ */
+#[Attribute(Attribute::TARGET_CLASS)]
+final class NonInstantiableClass {
+    public readonly string $message;
+
+    public function __construct(string $message) {}
+}

Zend/zend_attributes_arginfo.h

@@ -20,6 +20,7 @@
 #include "zend.h"
 #include "zend_API.h"
 #include "zend_closures.h"
+#include "zend_attributes.h"
 #include "zend_exceptions.h"
 #include "zend_interfaces.h"
 #include "zend_objects.h"
@@ -448,13 +449,6 @@ ZEND_METHOD(Closure, getCurrent)
 	RETURN_OBJ_COPY(obj);
 }
 
-static ZEND_COLD zend_function *zend_closure_get_constructor(zend_object *object) /* {{{ */
-{
-	zend_throw_error(NULL, "Instantiation of class Closure is not allowed");
-	return NULL;
-}
-/* }}} */
-
 /* int return due to Object Handler API */
 static int zend_closure_compare(zval *o1, zval *o2) /* {{{ */
 {
@@ -736,7 +730,6 @@ void zend_register_closure_ce(void) /* {{{ */
 
 	memcpy(&closure_handlers, &std_object_handlers, sizeof(zend_object_handlers));
 	closure_handlers.free_obj = zend_closure_free_storage;
-	closure_handlers.get_constructor = zend_closure_get_constructor;
 	closure_handlers.get_method = zend_closure_get_method;
 	closure_handlers.compare = zend_closure_compare;
 	closure_handlers.clone_obj = zend_closure_clone;