ext/standard/array.c: make enum SORT_REGULAR ordering deterministic

- Compare backed enums via their stored backing values so SORT_REGULAR’s
  common path no longer fetches and compares case names; unit enums
  still fall back to case-name ordering, with object handles as the
  deterministic tie-breaker
- Add ext/standard/tests/array/sort/sort_enum_stability.phpt to ensure
  both unit and backed enums produce the same sorted order regardless of
  access order

Author: jmarble

ext/standard/array.c

@@ -28,6 +28,7 @@
 #include <string.h>
 #include "zend_globals.h"
 #include "zend_interfaces.h"
+#include "zend_enum.h"
 #include "php_array.h"
 #include "basic_functions.h"
 #include "php_string.h"
@@ -137,13 +138,61 @@ static zend_always_inline int php_array_compare_enum_zvals(zval *lhs, zval *rhs)
 	const bool rhs_enum = php_array_is_enum_zval(rhs);
 
 	if (lhs_enum && rhs_enum) {
-		if (Z_OBJ_P(lhs) == Z_OBJ_P(rhs)) {
+		zend_object *lhs_obj = Z_OBJ_P(lhs);
+		zend_object *rhs_obj = Z_OBJ_P(rhs);
+
+		if (lhs_obj == rhs_obj) {
 			return 0;
 		}
 
-		uintptr_t lhs_ptr = (uintptr_t) Z_OBJ_P(lhs);
-		uintptr_t rhs_ptr = (uintptr_t) Z_OBJ_P(rhs);
-		return lhs_ptr < rhs_ptr ? -1 : 1;
+		if (lhs_obj->ce != rhs_obj->ce) {
+			return zend_compare_non_numeric_strings(lhs_obj->ce->name, rhs_obj->ce->name);
+		}
+
+		if (lhs_obj->ce->enum_backing_type != IS_UNDEF) {
+			zval *lhs_value = zend_enum_fetch_case_value(lhs_obj);
+			zval *rhs_value = zend_enum_fetch_case_value(rhs_obj);
+
+			if (lhs_obj->ce->enum_backing_type == IS_LONG) {
+				zend_long lhs_long = Z_LVAL_P(lhs_value);
+				zend_long rhs_long = Z_LVAL_P(rhs_value);
+				if (lhs_long != rhs_long) {
+					return lhs_long < rhs_long ? -1 : 1;
+				}
+			} else {
+				ZEND_ASSERT(lhs_obj->ce->enum_backing_type == IS_STRING);
+				zend_string *lhs_str = Z_STR_P(lhs_value);
+				zend_string *rhs_str = Z_STR_P(rhs_value);
+				if (lhs_str != rhs_str) {
+					zend_ulong lhs_hash = ZSTR_HASH(lhs_str);
+					zend_ulong rhs_hash = ZSTR_HASH(rhs_str);
+					if (lhs_hash != rhs_hash) {
+						return lhs_hash < rhs_hash ? -1 : 1;
+					}
+					int cmp = zend_compare_non_numeric_strings(lhs_str, rhs_str);
+					if (cmp != 0) {
+						return cmp;
+					}
+				}
+			}
+		}
+
+		zend_string *lhs_case = Z_STR_P(zend_enum_fetch_case_name(lhs_obj));
+		zend_string *rhs_case = Z_STR_P(zend_enum_fetch_case_name(rhs_obj));
+		if (lhs_case != rhs_case) {
+			zend_ulong lhs_hash = ZSTR_HASH(lhs_case);
+			zend_ulong rhs_hash = ZSTR_HASH(rhs_case);
+			if (lhs_hash != rhs_hash) {
+				return lhs_hash < rhs_hash ? -1 : 1;
+			}
+			int cmp = zend_compare_non_numeric_strings(lhs_case, rhs_case);
+			if (cmp != 0) {
+				return cmp;
+			}
+		}
+
+		/* Should not happen for userland enums, but keep ordering deterministic for transitivity. */
+		return lhs_obj->handle < rhs_obj->handle ? -1 : 1;
 	}
 
 	return lhs_enum ? 1 : -1;

ext/standard/tests/array/sort/sort_enum_stability.phpt

@@ -0,0 +1,68 @@
+--TEST--
+SORT_REGULAR produces stable ordering for enums regardless of access order
+--FILE--
+<?php
+enum UnitEnumExample {
+    case Hearts;
+    case Spades;
+    case Clubs;
+    case Diamonds;
+}
+
+enum BackedEnumExample: string {
+    case Alpha = 'alpha';
+    case Beta = 'beta';
+    case Gamma = 'gamma';
+    case Delta = 'delta';
+}
+
+function build_cases(string $enumClass, array $order): array {
+    $cases = [];
+    foreach ($order as $case) {
+        $cases[] = constant($enumClass . "::$case");
+    }
+    return $cases;
+}
+
+function sorted_unit(array $order): array {
+    $cases = build_cases(UnitEnumExample::class, $order);
+    sort($cases, SORT_REGULAR);
+    return array_map(fn(UnitEnumExample $c) => $c->name, $cases);
+}
+
+function sorted_backed(array $order): array {
+    $cases = build_cases(BackedEnumExample::class, $order);
+    sort($cases, SORT_REGULAR);
+    return array_map(fn(BackedEnumExample $c) => $c->value, $cases);
+}
+
+$unitOrders = [
+    ['Hearts', 'Spades', 'Clubs', 'Diamonds'],
+    ['Diamonds', 'Clubs', 'Spades', 'Hearts'],
+    ['Spades', 'Hearts', 'Diamonds', 'Clubs'],
+];
+
+$unitBaseline = sorted_unit($unitOrders[0]);
+foreach ($unitOrders as $idx => $order) {
+    if (sorted_unit($order) !== $unitBaseline) {
+        echo "Unit enum order mismatch for permutation $idx\n";
+    }
+}
+
+$backedOrders = [
+    ['Alpha', 'Beta', 'Gamma', 'Delta'],
+    ['Delta', 'Gamma', 'Beta', 'Alpha'],
+    ['Beta', 'Alpha', 'Delta', 'Gamma'],
+];
+
+$backedBaseline = sorted_backed($backedOrders[0]);
+foreach ($backedOrders as $idx => $order) {
+    if (sorted_backed($order) !== $backedBaseline) {
+        echo "Backed enum order mismatch for permutation $idx\n";
+    }
+}
+
+echo "done\n";
+?>
+--EXPECT--
+done