fake closure comparison

Author: krakjoe

Zend/tests/closure_compare.phpt

@@ -0,0 +1,88 @@
+--TEST--
+Closure comparison
+--FILE--
+<?php
+function foo() {
+    static $var;
+}
+
+$closures[0] = Closure::fromCallable('foo');
+$closures[1] = Closure::fromCallable('foo');
+
+printf("foo == foo: %s\n", $closures[0] == $closures[1] ? "OK" : "FAIL");
+
+$closures[0] = Closure::fromCallable('strlen');
+$closures[1] = Closure::fromCallable('strlen');
+
+printf("strlen == strlen: %s\n", $closures[0] == $closures[1] ? "OK" : "FAIL");
+
+$closures[0] = Closure::fromCallable('strlen');
+$closures[1] = Closure::fromCallable('strrev');
+
+printf("strlen != strrev: %s\n", $closures[0] != $closures[1] ? "OK" : "FAIL");
+
+class Foo {
+    public function __call($method, $args) {
+    
+    }
+
+    public function exists() {}
+
+    public static function existsStatic() {}
+}
+
+class Bar extends Foo {}
+
+$closures[0] = Closure::fromCallable([Foo::class, "existsStatic"]);
+$closures[1] = Closure::fromCallable([Bar::class, "existsStatic"]);
+
+printf("foo::existsStatic != bar::existsStatic: %s\n", $closures[0] != $closures[1] ? "OK" : "FAIL");
+
+$foo = new Foo;
+
+$closures[0] = Closure::fromCallable([$foo, "exists"]);
+$closures[1] = $closures[0]->bindTo(new Foo);
+
+printf("foo#0::exists != foo#1::exists: %s\n", $closures[0] != $closures[1] ? "OK" : "FAIL");
+
+$closures[0] = Closure::fromCallable([$foo, "exists"]);
+$closures[1] = Closure::fromCallable([$foo, "exists"]);
+
+printf("foo::exists == foo::exists: %s\n", $closures[0] == $closures[1] ? "OK" : "FAIL");
+
+$closures[0] = Closure::fromCallable([$foo, "method"]);
+$closures[1] = Closure::fromCallable([$foo, "method"]);
+
+printf("foo::method == foo::method: %s\n", $closures[0] == $closures[1] ? "OK" : "FAIL");
+
+$closures[1] = $closures[1]->bindTo(new Bar);
+
+printf("foo::method != bar::method: %s\n", $closures[0] != $closures[1] ? "OK" : "FAIL");
+
+$closures[0] = Closure::fromCallable([$foo, "method"]);
+$closures[1] = Closure::fromCallable([$foo, "method2"]);
+
+printf("foo::method != foo::method2: %s\n", $closures[0] != $closures[1] ? "OK" : "FAIL");
+
+$closures[2] = Closure::fromCallable([$closures[0], "__invoke"]);
+$closures[3] = Closure::fromCallable([$closures[1], "__invoke"]);
+
+printf("Closure[0]::invoke != Closure[1]::invoke: %s\n", $closures[2] != $closures[3] ? "OK" : "FAIL");
+
+$closures[2] = Closure::fromCallable([$closures[0], "__invoke"]);
+$closures[3] = Closure::fromCallable([$closures[0], "__invoke"]);
+
+printf("Closure[0]::invoke == Closure[0]::invoke: %s\n", $closures[2] == $closures[3] ? "OK" : "FAIL");
+?>
+--EXPECT--
+foo == foo: OK
+strlen == strlen: OK
+strlen != strrev: OK
+foo::existsStatic != bar::existsStatic: OK
+foo#0::exists != foo#1::exists: OK
+foo::exists == foo::exists: OK
+foo::method == foo::method: OK
+foo::method != bar::method: OK
+foo::method != foo::method2: OK
+Closure[0]::invoke != Closure[1]::invoke: OK
+Closure[0]::invoke == Closure[0]::invoke: OK

Zend/zend_closures.c

@@ -377,10 +377,49 @@ static ZEND_COLD zend_function *zend_closure_get_constructor(zend_object *object
 }
 /* }}} */
 
+static zend_always_inline int zend_closure_compare_fakes(zend_closure *lhs, zend_closure *rhs) { /* {{{ */
+	if (Z_TYPE(lhs->this_ptr) == IS_OBJECT && Z_TYPE(rhs->this_ptr) == IS_OBJECT) {
+		if (Z_OBJ(lhs->this_ptr) != Z_OBJ(rhs->this_ptr)) {
+			return ZEND_UNCOMPARABLE;
+		}
+	}
+
+	if (lhs->called_scope != rhs->called_scope) {
+		return ZEND_UNCOMPARABLE;
+	}
+
+	if (lhs->func.type != rhs->func.type) {
+		return ZEND_UNCOMPARABLE;
+	}
+
+	if (lhs->func.type == ZEND_USER_FUNCTION) {
+		return lhs->func.op_array.opcodes != rhs->func.op_array.opcodes;
+	} else {
+		if (lhs->func.common.scope != rhs->func.common.scope) {
+			return ZEND_UNCOMPARABLE;
+		}
+
+		if (!zend_string_equals(lhs->func.common.function_name, rhs->func.common.function_name)) {
+			return ZEND_UNCOMPARABLE;
+		}
+	}
+
+	return 0;
+} /* }}} */
+
 /* int return due to Object Handler API */
 static int zend_closure_compare(zval *o1, zval *o2) /* {{{ */
 {
 	ZEND_COMPARE_OBJECTS_FALLBACK(o1, o2);
+
+	zend_closure *lhs = (zend_closure*) Z_OBJ_P(o1);
+	zend_closure *rhs = (zend_closure*) Z_OBJ_P(o2);
+
+	if (lhs->func.common.fn_flags & ZEND_ACC_FAKE_CLOSURE && 
+		rhs->func.common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
+		return zend_closure_compare_fakes(lhs, rhs);
+	}
+
 	return Z_OBJ_P(o1) != Z_OBJ_P(o2);
 }
 /* }}} */