Add SORT_STRICT option to array_unique()

cscott · cscott · commit 3b66d2908575 · 2021-12-22T16:58:25.000-05:00
Provide a way to request the use of strict comparison (===) when using
`array_unique`.  SORT_STRICT does no type conversion: values of
different types are ordered by their type.  For array/object values
which are == but not === we recursively compare the
elements/properties.  Arrays with identical elements will be identical
themselves; but for objects with identical properties which are not
identical we next compare class names and if that doesn't break the
tie we compare the `spl_object_id()` of the objects.
diff --git a/ext/standard/array.c b/ext/standard/array.c
@@ -103,6 +103,7 @@ PHP_MINIT_FUNCTION(array) /* {{{ */
 
 	REGISTER_LONG_CONSTANT("SORT_REGULAR", PHP_SORT_REGULAR, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("SORT_NUMERIC", PHP_SORT_NUMERIC, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("SORT_STRICT", PHP_SORT_STRICT, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("SORT_STRING", PHP_SORT_STRING, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("SORT_LOCALE_STRING", PHP_SORT_LOCALE_STRING, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("SORT_NATURAL", PHP_SORT_NATURAL, CONST_CS | CONST_PERSISTENT);
@@ -349,6 +350,102 @@ static zend_always_inline int php_array_data_compare_unstable_i(Bucket *f, Bucke
 }
 /* }}} */
 
+/* return int to be compatible with compare_func_t */
+static int hash_zval_strict_function(zval *z1, zval *z2) /* {{{ */
+{
+	ZVAL_DEREF(z1);
+	ZVAL_DEREF(z2);
+	// The most important thing about this comparison mode is that the result
+	// is 0 when zend_is_identical, and non-zero otherwise.
+	if (zend_is_identical(z1, z2)) {
+		return 0;
+	}
+	// Below this point, the return value should always be non-zero.
+	// If the types are different, compare based on type.
+	int t1 = Z_TYPE_P(z1);
+	int t2 = Z_TYPE_P(z2);
+	if ( t1 != t2 ) {
+		return (t1 > t2 ) ? 1 : -1;
+	}
+	// Both types are the same *but the values are not identical*
+	switch (t1) {
+	case IS_LONG:
+		return Z_LVAL_P(z1) > Z_LVAL_P(z2) ? 1 : -1;
+
+	case IS_DOUBLE:
+		return Z_DVAL_P(z1) > Z_DVAL_P(z2) ? 1 : -1;
+
+	case IS_STRING:
+		return zend_binary_strcmp(
+			Z_STRVAL_P(z1), Z_STRLEN_P(z1),
+			Z_STRVAL_P(z2), Z_STRLEN_P(z2)
+		);
+		
+	case IS_ARRAY:
+		// Do a recursive comparison.  Unlike for objects, if this recursive
+		// comparison returns 0, then the objects should have tested as
+		// identical above.
+		return zend_hash_compare(
+			Z_ARRVAL_P(z1), Z_ARRVAL_P(z2),
+			(compare_func_t) hash_zval_strict_function, 1 /* ordered */
+		);
+
+	case IS_OBJECT:
+	{
+		// Start with a recursive comparison like for arrays, for consistency.
+		// (This is deliberately not using the user-defined `compare` handler,
+		// nor is it using zend_std_compare_objects() because that uses
+		// zend_compare when examining properties, not a strict comparison.)
+		zend_object *zobj1 = Z_OBJ_P(z1);
+		zend_object *zobj2 = Z_OBJ_P(z2);
+		rebuild_object_properties(zobj1);
+		rebuild_object_properties(zobj2);
+		int c = zend_hash_compare(
+			zobj1->properties, zobj2->properties,
+			(compare_func_t) hash_zval_strict_function, 0 /* unordered */
+		);
+		if (c != 0) {
+			return (c > 0) ? 1 : -1;
+		}
+		// Properties are all identical.  Check the class name, since this
+		// is consistent across runs.
+		zend_string *name1 = Z_OBJCE_P(z1)->name;
+		zend_string *name2 = Z_OBJCE_P(z2)->name;
+		c = zend_binary_strcmp(name1->val, name1->len, name2->val, name2->len);
+		if (c != 0) {
+			return (c > 0) ? 1 : -1;
+		}
+		// Fall back on spl_object_id() value, which will probably vary
+		// non-deterministically between runs (alas).
+		ZEND_ASSERT(zobj1->handle != zobj2->handle);
+		return (zobj1->handle > zobj2->handle) ? 1 : -1;
+	}
+
+	case IS_RESOURCE:
+		// This will also likely vary non-deterministically between runs.
+		return Z_RES_HANDLE_P(z1) > Z_RES_HANDLE_P(z2) ? 1 : -1;
+
+	case IS_REFERENCE:
+		ZEND_ASSERT(0 && "Should have been dereferenced above");
+
+	case IS_UNDEF:
+	case IS_NULL:
+	case IS_FALSE:
+	case IS_TRUE:
+	default:
+		ZEND_ASSERT(0 && "Values w/ same type should be identical");
+		return 0;
+	}
+}
+/* }}} */
+
+
+static zend_always_inline int php_array_data_compare_strict_unstable_i(Bucket *f, Bucket *s) /* {{{ */
+{
+	return hash_zval_strict_function(&f->val, &s->val);
+}
+/* }}} */
+
 static zend_always_inline int php_array_data_compare_numeric_unstable_i(Bucket *f, Bucket *s) /* {{{ */
 {
 	return numeric_compare_function(&f->val, &s->val);
@@ -405,6 +502,7 @@ DEFINE_SORT_VARIANTS(key_compare_string_case);
 DEFINE_SORT_VARIANTS(key_compare_string);
 DEFINE_SORT_VARIANTS(key_compare_string_locale);
 DEFINE_SORT_VARIANTS(data_compare);
+DEFINE_SORT_VARIANTS(data_compare_strict);
 DEFINE_SORT_VARIANTS(data_compare_numeric);
 DEFINE_SORT_VARIANTS(data_compare_string_case);
 DEFINE_SORT_VARIANTS(data_compare_string);
@@ -527,6 +625,14 @@ static bucket_compare_func_t php_get_data_compare_func(zend_long sort_type, int
 			}
 			break;
 
+		case PHP_SORT_STRICT:
+			if (reverse) {
+				return php_array_reverse_data_compare_strict;
+			} else {
+				return php_array_data_compare_strict;
+			}
+			break;
+
 		case PHP_SORT_REGULAR:
 		default:
 			if (reverse) {
@@ -591,6 +697,14 @@ static bucket_compare_func_t php_get_data_compare_func_unstable(zend_long sort_t
 			}
 			break;
 
+		case PHP_SORT_STRICT:
+			if (reverse) {
+				return php_array_reverse_data_compare_strict_unstable;
+			} else {
+				return php_array_data_compare_strict_unstable;
+			}
+			break;
+
 		case PHP_SORT_REGULAR:
 		default:
 			if (reverse) {
diff --git a/ext/standard/php_array.h b/ext/standard/php_array.h
@@ -36,6 +36,7 @@ PHPAPI zend_long php_count_recursive(HashTable *ht);
 #define PHP_SORT_ASC                4
 #define PHP_SORT_LOCALE_STRING      5
 #define PHP_SORT_NATURAL            6
+#define PHP_SORT_STRICT             7
 #define PHP_SORT_FLAG_CASE          8
 
 #define COUNT_NORMAL      0
diff --git a/ext/standard/tests/array/array_unique_strict.phpt b/ext/standard/tests/array/array_unique_strict.phpt
@@ -0,0 +1,67 @@
+--TEST--
+Test array_unique() function : SORT_STRICT functionality
+--FILE--
+<?php
+echo "*** Testing array_unique() : SORT_STRICT functionality ***\n";
+
+var_dump( array_unique( [ "1234", 1234 ] ) );
+var_dump( array_unique( [ "1234", "1234" ], SORT_STRICT ) );
+var_dump( array_unique( [ "1234", 1234 ], SORT_STRICT ) );
+
+var_dump( array_unique( [ 0, "0", 0.0, "0.0", '', null, null ] ) );
+var_dump( array_unique( [ 0, "0", 0.0, "0.0", '', null, null ], SORT_STRICT ) );
+
+// These are more values which are == but not ===
+$a = (object)[];
+$b = (object)[];
+$a2 = [ $a ];
+$b2 = [ $b ];
+$a3 = (object)[ 'foo' => $a ];
+$b3 = (object)[ 'foo' => $b ];
+var_dump( $a == $b && $a2 == $b2 && $a3 == $b3 );
+var_dump( $a === $b || $a2 === $b2 || $a3 === $b3 );
+
+var_dump( count( array_unique( [ $a, $b, $a2, $b2, $a3, $b3 ], SORT_STRICT ) ) );
+
+?>
+--EXPECT--
+*** Testing array_unique() : SORT_STRICT functionality ***
+array(1) {
+  [0]=>
+  string(4) "1234"
+}
+array(1) {
+  [0]=>
+  string(4) "1234"
+}
+array(2) {
+  [0]=>
+  string(4) "1234"
+  [1]=>
+  int(1234)
+}
+array(3) {
+  [0]=>
+  int(0)
+  [3]=>
+  string(3) "0.0"
+  [4]=>
+  string(0) ""
+}
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  string(1) "0"
+  [2]=>
+  float(0)
+  [3]=>
+  string(3) "0.0"
+  [4]=>
+  string(0) ""
+  [5]=>
+  NULL
+}
+bool(true)
+bool(false)
+int(6)
