com php-src: Add Closure::fromCallable().: Zend/tests/closures/closureFunction.inc Zend/tests/closures/clo sureFunction_basic.phpt
Zend/tests/closures/closureFuncti on_error.phpt Zend/zend_closures.c ext/reflection/p hp_reflection.c
| From: | Joe Watkins | Date: | Sun, 15 May 2016 16:39:47 +0000 |
| Subject: | com php-src: Add Closure::fromCallable().: Zend/tests/closures/closureFunction.inc Zend/tests/closures/clo sureFunction_basic.phpt Zend/tests/closures/closureFuncti on_error.phpt Zend/zend_closures.c ext/reflection/p hp_reflection.c |
||
| Groups: | php.cvs | ||
| Request: | Send a blank email to php-cvs+get-92768@lists.php.net to get a copy of this message | ||
Commit: 63ca65daef736f9a6b67db5b633e4c378bea1b90
Author: Danack <Danack@basereality.com> Sun, 15 May 2016 17:39:47 +0100
Parents: bc63879d46c1de687ac859bff1306511d8d1ba9e
Branches: master
Link: http://git.php.net/?p=php-src.git;a=commitdiff;h=63ca65daef736f9a6b67db5b633e4c378bea1b90
Log:
Add Closure::fromCallable().
Add the ability to create closures from callable as part of RFC: https://wiki.php.net/rfc/closurefromcallable
Changed paths:
A Zend/tests/closures/closureFunction.inc
A Zend/tests/closures/closureFunction_basic.phpt
A Zend/tests/closures/closureFunction_error.phpt
M Zend/zend_closures.c
M ext/reflection/php_reflection.c
diff --git a/Zend/tests/closures/closureFunction.inc b/Zend/tests/closures/closureFunction.inc new file mode 100644 index 0000000..5f0f220 --- /dev/null +++ b/Zend/tests/closures/closureFunction.inc @@ -0,0 +1,187 @@ +<?php + +function bar($param1) +{ + return $param1; +} + + +$closure = function($param1) { + return $param1; +}; + +function test($fn) +{ + static $count = 0; + $input = "foo".$count; + $count++; + + $output = $fn($input); + return $input === $output; +} + +class Foo +{ + public static function publicStaticFunction($param1) + { + return $param1; + } + + private static function privateStaticFunction($param1) + { + return $param1; + } + + protected static function protectedStaticFunction($param1) + { + return $param1; + } + + private function privateInstanceFunc($param1) + { + return $param1; + } + + protected function protectedInstanceFunc($param1) + { + return $param1; + } + + + public function publicInstanceFunc($param1) + { + return $param1; + } + + public function closePrivateValid() + { + return Closure::fromCallable([$this, 'privateInstanceFunc']); + } + + public function closePrivateStatic() + { + return Closure::fromCallable([__CLASS__, 'privateStaticFunction']); + } + + public function bar($param1) + { + echo "this is bar\n"; + } + + public function getCallable() + { + return Closure::fromCallable([$this, 'publicInstanceFunc']); + } + + public function getSelfPublicInstance() + { + return Closure::fromCallable([$this, 'publicInstanceFunc']); + } + + public function getSelfColonPublicInstanceMethod() + { + return Closure::fromCallable('self::publicInstanceFunc'); + } +} + + + +class SubFoo extends Foo { + + public function closePrivateStaticInvalid() + { + return Closure::fromCallable([__CLASS__, 'privateStaticFunction']); + } + + + public function closePrivateInvalid() + { + return Closure::fromCallable([$this, 'privateInstanceFunc']); + } + + public function closeProtectedStaticMethod() + { + return Closure::fromCallable([__CLASS__, 'protectedStaticFunction']); + } + + public function closeProtectedValid() + { + return Closure::fromCallable([$this, 'protectedInstanceFunc']); + } + + public function getParentPublicInstanceMethod() + { + return Closure::fromCallable('parent::publicInstanceFunc'); + } + + public function getSelfColonParentPublicInstanceMethod() + { + return Closure::fromCallable('self::publicInstanceFunc'); + } + + + public function getSelfColonParentProtectedInstanceMethod() + { + return Closure::fromCallable('self::protectedInstanceFunc'); + } + + public function getSelfColonParentPrivateInstanceMethod() + { + return Closure::fromCallable('self::privateInstanceFunc'); + } +} + + +class MagicCall +{ + public function __call($name, $arguments) + { + $info = ['__call']; + $info[] = $name; + $info = array_merge($info, $arguments); + return implode(',', $info); + } + + public static function __callStatic($name, $arguments) + { + $info = ['__callStatic']; + $info[] = $name; + $info = array_merge($info, $arguments); + return implode(',', $info); + } +} + + + +class PublicInvokable +{ + public function __invoke($param1) + { + return $param1; + } +} + + +function functionAccessProtected() +{ + $foo = new Foo; + + return Closure::fromCallable([$foo, 'protectedStaticFunction']); +} + +function functionAccessPrivate() +{ + $foo = new Foo; + + return Closure::fromCallable([$foo, 'privateStaticFunction']); +} + + +function functionAccessMethodDoesntExist() +{ + $foo = new Foo; + + return Closure::fromCallable([$foo, 'thisDoesNotExist']); +} + +?> diff --git a/Zend/tests/closures/closureFunction_basic.phpt b/Zend/tests/closures/closureFunction_basic.phpt new file mode 100644 index 0000000..676c643 --- /dev/null +++ b/Zend/tests/closures/closureFunction_basic.phpt @@ -0,0 +1,122 @@ +--TEST-- +Testing closure() functionality +--FILE-- +<?php + +include('closureFunction.inc'); + +echo 'Access public static function'; +$fn = Closure::fromCallable(['Foo', 'publicStaticFunction']); +echo $fn(" OK".PHP_EOL); + +echo 'Access public static function with different case'; +$fn = Closure::fromCallable(['fOo', 'publicStaticfUNCTION']); +echo $fn(" OK".PHP_EOL); + +echo 'Access public static function with colon scheme'; +$fn = Closure::fromCallable('Foo::publicStaticFunction'); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of object'; +$fn = Closure::fromCallable([new Foo, 'publicInstanceFunc']); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of parent object through parent:: '; +$fn = Closure::fromCallable([new Foo, 'publicInstanceFunc']); +echo $fn(" OK".PHP_EOL); + +echo 'Function that exists'; +$fn = Closure::fromCallable('bar'); +echo $fn(" OK".PHP_EOL); + +echo 'Function that exists with different spelling'; +$fn = Closure::fromCallable('BAR'); +echo $fn(" OK".PHP_EOL); + +echo 'Closure is already a closure'; +$fn = Closure::fromCallable($closure); +echo $fn(" OK".PHP_EOL); + +echo 'Class with public invokable'; +$fn = Closure::fromCallable(new PublicInvokable); +echo $fn(" OK".PHP_EOL); + +echo "Instance return private method as callable"; +$foo = new Foo; +$fn = $foo->closePrivateValid(); +echo $fn(" OK".PHP_EOL); + +echo "Instance return private static method as callable"; +$foo = new Foo; +$fn = $foo->closePrivateStatic(); +echo $fn(" OK".PHP_EOL); + +echo 'Instance return protected static method as callable'; +$subFoo = new SubFoo; +$fn = $subFoo->closeProtectedStaticMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Subclass closure over parent class protected method'; +$subFoo = new SubFoo; +$fn = $subFoo->closeProtectedValid(); +echo $fn(" OK".PHP_EOL); + +echo 'Subclass closure over parent class static protected method'; +$subFoo = new SubFoo; +$fn = $subFoo->closeProtectedStaticMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of parent object through "parent::" '; +$subFoo = new SubFoo; +$fn = $subFoo->getParentPublicInstanceMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of self object through "self::" '; +$foo = new Foo; +$fn = $foo->getSelfColonPublicInstanceMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of parent object through "self::" to parent method'; +$foo = new SubFoo; +$fn = $foo->getSelfColonParentPublicInstanceMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Access proteced instance method of parent object through "self::" to parent method'; +$foo = new SubFoo; +$fn = $foo->getSelfColonParentProtectedInstanceMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'MagicCall __call instance method '; +$fn = Closure::fromCallable([new MagicCall, 'nonExistentMethod']); +echo $fn(" OK".PHP_EOL); + +echo 'MagicCall __callStatic static method '; +$fn = Closure::fromCallable(['MagicCall', 'nonExistentMethod']); +echo $fn(" OK".PHP_EOL); + + +?> +===DONE=== +--EXPECT-- + +Access public static function OK +Access public static function with different case OK +Access public static function with colon scheme OK +Access public instance method of object OK +Access public instance method of parent object through parent:: OK +Function that exists OK +Function that exists with different spelling OK +Closure is already a closure OK +Class with public invokable OK +Instance return private method as callable OK +Instance return private static method as callable OK +Instance return protected static method as callable OK +Subclass closure over parent class protected method OK +Subclass closure over parent class static protected method OK +Access public instance method of parent object through "parent::" OK +Access public instance method of self object through "self::" OK +Access public instance method of parent object through "self::" to parent method OK +Access proteced instance method of parent object through "self::" to parent method OK +MagicCall __call instance method __call,nonExistentMethod, OK +MagicCall __callStatic static method __callStatic,nonExistentMethod, OK +===DONE=== diff --git a/Zend/tests/closures/closureFunction_error.phpt b/Zend/tests/closures/closureFunction_error.phpt new file mode 100644 index 0000000..1200aad --- /dev/null +++ b/Zend/tests/closures/closureFunction_error.phpt @@ -0,0 +1,215 @@ +--TEST-- +Testing closure() functionality +--FILE-- +<?php + +include('closureFunction.inc'); + +echo 'Cannot access privateInstance method statically'."\n"; +try { + $fn = Closure::fromCallable(['Foo', 'privateInstanceFunc']); + echo "Test failed to fail and return was : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + + +echo 'Cannot access privateInstance method statically with colon scheme'."\n"; +try { + $fn = Closure::fromCallable('Foo::privateInstanceFunc'); + echo "Test failed to fail and return was : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Cannot access privateInstance method'."\n"; +try { + $fn = Closure::fromCallable([new Foo, 'privateInstanceFunc']); + echo "Test failed to fail and return was : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'SubClass cannot access private instance method'."\n"; +try { + $fn = Closure::fromCallable([new SubFoo, 'privateInstanceFunc']); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Cannot access private static function of instance'."\n"; +try { + $fn = Closure::fromCallable([new Foo, 'privateStaticFunction']); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Cannot access private static method statically'."\n"; +try { + $fn = Closure::fromCallable(['Foo', 'privateStaticFunction']); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Cannot access private static method statically with colon scheme'."\n"; +try { + $fn = Closure::fromCallable('Foo::privateStaticFunction'); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Non-existent method should fail'."\n"; +try { + $fn = Closure::fromCallable('Foo::nonExistentFunction'); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Non-existent class should fail'."\n"; +try { + $fn = Closure::fromCallable(['NonExistentClass', 'foo']); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Non-existent function should fail'."\n"; +try { + $fn = Closure::fromCallable('thisDoesNotExist'); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + + +echo 'Subclass cannot closure over parent private instance method'."\n"; +try { + $subFoo = new SubFoo; + $fn = $subFoo->closePrivateInvalid(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Subclass cannot closure over parant private static method'."\n"; +try { + $subFoo = new SubFoo; + $fn = $subFoo->closePrivateStaticInvalid(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Function scope cannot closure over protected instance method'."\n"; +try { + $fn = functionAccessProtected(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Function scope cannot closure over private instance method'."\n"; +try { + $fn = functionAccessPrivate(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Access private instance method of parent object through "self::" to parent method'."\n"; +try { + $foo = new SubFoo; + $fn = $foo->getSelfColonParentPrivateInstanceMethod(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo "OK\n"; + +?> +===DONE=== +--EXPECT-- + +Cannot access privateInstance method statically +Cannot access privateInstance method statically with colon scheme +Cannot access privateInstance method +SubClass cannot access private instance method +Cannot access private static function of instance +Cannot access private static method statically +Cannot access private static method statically with colon scheme +Non-existent method should fail +Non-existent class should fail +Non-existent function should fail +Subclass cannot closure over parent private instance method +Subclass cannot closure over parant private static method +Function scope cannot closure over protected instance method +Function scope cannot closure over private instance method +Access private instance method of parent object through "self::" to parent method +OK +===DONE=== diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index 810ac6a..adf5981 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -235,6 +235,105 @@ ZEND_METHOD(Closure, bind) } /* }}} */ +static void zend_closure_call_magic(INTERNAL_FUNCTION_PARAMETERS) { + zend_fcall_info fci; + zend_fcall_info_cache fcc; + + memset(&fci, 0, sizeof(zend_fcall_info)); + memset(&fci, 0, sizeof(zend_fcall_info_cache)); + + fci.size = sizeof(zend_fcall_info); + fci.retval = return_value; + + fcc.initialized = 1; + fcc.function_handler = (zend_function *) EX(func)->common.arg_info; + fci.params = (zval*) emalloc(sizeof(zval) * 2); + fci.param_count = 2; + ZVAL_STR(&fci.params[0], EX(func)->common.function_name); + array_init(&fci.params[1]); + zend_copy_parameters_array(ZEND_NUM_ARGS(), &fci.params[1]); + + fci.object = Z_OBJ(EX(This)); + fcc.object = Z_OBJ(EX(This)); + fcc.calling_scope = zend_get_executed_scope(); + + zend_call_function(&fci, &fcc); + + zval_ptr_dtor(&fci.params[0]); + zval_ptr_dtor(&fci.params[1]); + efree(fci.params); +} + + +static int zend_create_closure_from_callable(zval *return_value, zval *callable, char **error) { + zend_fcall_info_cache fcc; + zend_function *mptr; + zval instance; + + if (!zend_is_callable_ex(callable, NULL, 0, NULL, &fcc, error)) { + return FAILURE; + } + + mptr = fcc.function_handler; + if (mptr == NULL) { + return FAILURE; + } + + if (mptr->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) { + zend_internal_function call; + memset(&call, 0, sizeof(zend_internal_function)); + + call.type = ZEND_INTERNAL_FUNCTION; + call.handler = zend_closure_call_magic; + call.function_name = mptr->common.function_name; + call.arg_info = (zend_internal_arg_info *) mptr->common.prototype; + call.scope = mptr->common.scope; + + zend_free_trampoline(mptr); + mptr = (zend_function *) &call; + } + + ZVAL_OBJ(&instance, fcc.object); + zend_create_closure(return_value, mptr, mptr->common.scope, fcc.object ? fcc.object->ce : NULL, fcc.object ? &instance : NULL); + + return SUCCESS; +} + + +/* {{{ proto Closure Closure::fromCallable(callable callable) + Create a closure from a callabl using the current scope. */ +ZEND_METHOD(Closure, fromCallable) +{ + zval *callable; + int success; + char *error = NULL; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &callable) == FAILURE) { + return; + } + + if (Z_TYPE_P(callable) == IS_OBJECT && instanceof_function(Z_OBJCE_P(callable), zend_ce_closure)) { + // It's already a closure + RETURN_ZVAL(callable, 1, 0); + } + + // create closure as if it were called from parent scope + EG(current_execute_data) = EX(prev_execute_data); + success = zend_create_closure_from_callable(return_value, callable, &error); + EG(current_execute_data) = execute_data; + + if (success == FAILURE) { + zend_clear_exception(); + if (error) { + zend_throw_exception_ex(zend_ce_type_error, 0, "Failed to create closure from callable: %s", error); + efree(error); + } else { + zend_throw_exception_ex(zend_ce_type_error, 0, "Failed to create closure from callable"); + } + } +} +/* }}} */ + static ZEND_COLD zend_function *zend_closure_get_constructor(zend_object *object) /* {{{ */ { zend_throw_error(NULL, "Instantiation of 'Closure' is not allowed"); @@ -489,11 +588,16 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_call, 0, 0, 1) ZEND_ARG_VARIADIC_INFO(0, parameters) ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_fromcallable, 0, 0, 1) + ZEND_ARG_INFO(0, newthis) +ZEND_END_ARG_INFO() + static const zend_function_entry closure_functions[] = { ZEND_ME(Closure, __construct, NULL, ZEND_ACC_PRIVATE) ZEND_ME(Closure, bind, arginfo_closure_bind, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) ZEND_MALIAS(Closure, bindTo, bind, arginfo_closure_bindto, ZEND_ACC_PUBLIC) ZEND_ME(Closure, call, arginfo_closure_call, ZEND_ACC_PUBLIC) + ZEND_ME(Closure, fromCallable, arginfo_closure_fromcallable, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) ZEND_FE_END }; diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 13003ca..ac6c00d 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -1633,6 +1633,30 @@ ZEND_METHOD(reflection_function, export) } /* }}} */ + +static zend_function *_find_function_pointer(char *name_str, int name_len) { + char *lcname, *nsname; + zend_function *fptr; + + lcname = zend_str_tolower_dup(name_str, name_len); + + /* Ignore leading "\" */ + nsname = lcname; + if (lcname[0] == '\\') { + nsname = &lcname[1]; + name_len--; + } + + if ((fptr = zend_hash_str_find_ptr(EG(function_table), nsname, name_len)) == NULL) { + efree(lcname); + return NULL; + } + efree(lcname); + + return fptr; +} + + /* {{{ proto public void ReflectionFunction::__construct(string name) Constructor. Throws an Exception in case the given function does not exist */ ZEND_METHOD(reflection_function, __construct) @@ -1656,23 +1680,12 @@ ZEND_METHOD(reflection_function, __construct) if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { return; } - - lcname = zend_str_tolower_dup(name_str, name_len); - - /* Ignore leading "\" */ - nsname = lcname; - if (lcname[0] == '\\') { - nsname = &lcname[1]; - name_len--; - } - - if ((fptr = zend_hash_str_find_ptr(EG(function_table), nsname, name_len)) == NULL) { - efree(lcname); + fptr = _find_function_pointer(name_str, name_len); + if (fptr == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Function %s() does not exist", name_str); - return; + return; } - efree(lcname); } ZVAL_STR_COPY(&name, fptr->common.function_name); @@ -6793,6 +6806,10 @@ static const zend_function_entry reflection_zend_extension_functions[] = { }; /* }}} */ +ZEND_BEGIN_ARG_INFO_EX(arginfo_closure, 0, 0, 1) + ZEND_ARG_INFO(0, callable) +ZEND_END_ARG_INFO() + const zend_function_entry reflection_ext_functions[] = { /* {{{ */ PHP_FE_END }; /* }}} */
diff --git a/Zend/tests/closures/closureFunction.inc b/Zend/tests/closures/closureFunction.inc new file mode 100644 index 0000000..5f0f220 --- /dev/null +++ b/Zend/tests/closures/closureFunction.inc @@ -0,0 +1,187 @@ +<?php + +function bar($param1) +{ + return $param1; +} + + +$closure = function($param1) { + return $param1; +}; + +function test($fn) +{ + static $count = 0; + $input = "foo".$count; + $count++; + + $output = $fn($input); + return $input === $output; +} + +class Foo +{ + public static function publicStaticFunction($param1) + { + return $param1; + } + + private static function privateStaticFunction($param1) + { + return $param1; + } + + protected static function protectedStaticFunction($param1) + { + return $param1; + } + + private function privateInstanceFunc($param1) + { + return $param1; + } + + protected function protectedInstanceFunc($param1) + { + return $param1; + } + + + public function publicInstanceFunc($param1) + { + return $param1; + } + + public function closePrivateValid() + { + return Closure::fromCallable([$this, 'privateInstanceFunc']); + } + + public function closePrivateStatic() + { + return Closure::fromCallable([__CLASS__, 'privateStaticFunction']); + } + + public function bar($param1) + { + echo "this is bar\n"; + } + + public function getCallable() + { + return Closure::fromCallable([$this, 'publicInstanceFunc']); + } + + public function getSelfPublicInstance() + { + return Closure::fromCallable([$this, 'publicInstanceFunc']); + } + + public function getSelfColonPublicInstanceMethod() + { + return Closure::fromCallable('self::publicInstanceFunc'); + } +} + + + +class SubFoo extends Foo { + + public function closePrivateStaticInvalid() + { + return Closure::fromCallable([__CLASS__, 'privateStaticFunction']); + } + + + public function closePrivateInvalid() + { + return Closure::fromCallable([$this, 'privateInstanceFunc']); + } + + public function closeProtectedStaticMethod() + { + return Closure::fromCallable([__CLASS__, 'protectedStaticFunction']); + } + + public function closeProtectedValid() + { + return Closure::fromCallable([$this, 'protectedInstanceFunc']); + } + + public function getParentPublicInstanceMethod() + { + return Closure::fromCallable('parent::publicInstanceFunc'); + } + + public function getSelfColonParentPublicInstanceMethod() + { + return Closure::fromCallable('self::publicInstanceFunc'); + } + + + public function getSelfColonParentProtectedInstanceMethod() + { + return Closure::fromCallable('self::protectedInstanceFunc'); + } + + public function getSelfColonParentPrivateInstanceMethod() + { + return Closure::fromCallable('self::privateInstanceFunc'); + } +} + + +class MagicCall +{ + public function __call($name, $arguments) + { + $info = ['__call']; + $info[] = $name; + $info = array_merge($info, $arguments); + return implode(',', $info); + } + + public static function __callStatic($name, $arguments) + { + $info = ['__callStatic']; + $info[] = $name; + $info = array_merge($info, $arguments); + return implode(',', $info); + } +} + + + +class PublicInvokable +{ + public function __invoke($param1) + { + return $param1; + } +} + + +function functionAccessProtected() +{ + $foo = new Foo; + + return Closure::fromCallable([$foo, 'protectedStaticFunction']); +} + +function functionAccessPrivate() +{ + $foo = new Foo; + + return Closure::fromCallable([$foo, 'privateStaticFunction']); +} + + +function functionAccessMethodDoesntExist() +{ + $foo = new Foo; + + return Closure::fromCallable([$foo, 'thisDoesNotExist']); +} + +?> diff --git a/Zend/tests/closures/closureFunction_basic.phpt b/Zend/tests/closures/closureFunction_basic.phpt new file mode 100644 index 0000000..676c643 --- /dev/null +++ b/Zend/tests/closures/closureFunction_basic.phpt @@ -0,0 +1,122 @@ +--TEST-- +Testing closure() functionality +--FILE-- +<?php + +include('closureFunction.inc'); + +echo 'Access public static function'; +$fn = Closure::fromCallable(['Foo', 'publicStaticFunction']); +echo $fn(" OK".PHP_EOL); + +echo 'Access public static function with different case'; +$fn = Closure::fromCallable(['fOo', 'publicStaticfUNCTION']); +echo $fn(" OK".PHP_EOL); + +echo 'Access public static function with colon scheme'; +$fn = Closure::fromCallable('Foo::publicStaticFunction'); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of object'; +$fn = Closure::fromCallable([new Foo, 'publicInstanceFunc']); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of parent object through parent:: '; +$fn = Closure::fromCallable([new Foo, 'publicInstanceFunc']); +echo $fn(" OK".PHP_EOL); + +echo 'Function that exists'; +$fn = Closure::fromCallable('bar'); +echo $fn(" OK".PHP_EOL); + +echo 'Function that exists with different spelling'; +$fn = Closure::fromCallable('BAR'); +echo $fn(" OK".PHP_EOL); + +echo 'Closure is already a closure'; +$fn = Closure::fromCallable($closure); +echo $fn(" OK".PHP_EOL); + +echo 'Class with public invokable'; +$fn = Closure::fromCallable(new PublicInvokable); +echo $fn(" OK".PHP_EOL); + +echo "Instance return private method as callable"; +$foo = new Foo; +$fn = $foo->closePrivateValid(); +echo $fn(" OK".PHP_EOL); + +echo "Instance return private static method as callable"; +$foo = new Foo; +$fn = $foo->closePrivateStatic(); +echo $fn(" OK".PHP_EOL); + +echo 'Instance return protected static method as callable'; +$subFoo = new SubFoo; +$fn = $subFoo->closeProtectedStaticMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Subclass closure over parent class protected method'; +$subFoo = new SubFoo; +$fn = $subFoo->closeProtectedValid(); +echo $fn(" OK".PHP_EOL); + +echo 'Subclass closure over parent class static protected method'; +$subFoo = new SubFoo; +$fn = $subFoo->closeProtectedStaticMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of parent object through "parent::" '; +$subFoo = new SubFoo; +$fn = $subFoo->getParentPublicInstanceMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of self object through "self::" '; +$foo = new Foo; +$fn = $foo->getSelfColonPublicInstanceMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Access public instance method of parent object through "self::" to parent method'; +$foo = new SubFoo; +$fn = $foo->getSelfColonParentPublicInstanceMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'Access proteced instance method of parent object through "self::" to parent method'; +$foo = new SubFoo; +$fn = $foo->getSelfColonParentProtectedInstanceMethod(); +echo $fn(" OK".PHP_EOL); + +echo 'MagicCall __call instance method '; +$fn = Closure::fromCallable([new MagicCall, 'nonExistentMethod']); +echo $fn(" OK".PHP_EOL); + +echo 'MagicCall __callStatic static method '; +$fn = Closure::fromCallable(['MagicCall', 'nonExistentMethod']); +echo $fn(" OK".PHP_EOL); + + +?> +===DONE=== +--EXPECT-- + +Access public static function OK +Access public static function with different case OK +Access public static function with colon scheme OK +Access public instance method of object OK +Access public instance method of parent object through parent:: OK +Function that exists OK +Function that exists with different spelling OK +Closure is already a closure OK +Class with public invokable OK +Instance return private method as callable OK +Instance return private static method as callable OK +Instance return protected static method as callable OK +Subclass closure over parent class protected method OK +Subclass closure over parent class static protected method OK +Access public instance method of parent object through "parent::" OK +Access public instance method of self object through "self::" OK +Access public instance method of parent object through "self::" to parent method OK +Access proteced instance method of parent object through "self::" to parent method OK +MagicCall __call instance method __call,nonExistentMethod, OK +MagicCall __callStatic static method __callStatic,nonExistentMethod, OK +===DONE=== diff --git a/Zend/tests/closures/closureFunction_error.phpt b/Zend/tests/closures/closureFunction_error.phpt new file mode 100644 index 0000000..1200aad --- /dev/null +++ b/Zend/tests/closures/closureFunction_error.phpt @@ -0,0 +1,215 @@ +--TEST-- +Testing closure() functionality +--FILE-- +<?php + +include('closureFunction.inc'); + +echo 'Cannot access privateInstance method statically'."\n"; +try { + $fn = Closure::fromCallable(['Foo', 'privateInstanceFunc']); + echo "Test failed to fail and return was : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + + +echo 'Cannot access privateInstance method statically with colon scheme'."\n"; +try { + $fn = Closure::fromCallable('Foo::privateInstanceFunc'); + echo "Test failed to fail and return was : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Cannot access privateInstance method'."\n"; +try { + $fn = Closure::fromCallable([new Foo, 'privateInstanceFunc']); + echo "Test failed to fail and return was : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'SubClass cannot access private instance method'."\n"; +try { + $fn = Closure::fromCallable([new SubFoo, 'privateInstanceFunc']); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Cannot access private static function of instance'."\n"; +try { + $fn = Closure::fromCallable([new Foo, 'privateStaticFunction']); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Cannot access private static method statically'."\n"; +try { + $fn = Closure::fromCallable(['Foo', 'privateStaticFunction']); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Cannot access private static method statically with colon scheme'."\n"; +try { + $fn = Closure::fromCallable('Foo::privateStaticFunction'); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Non-existent method should fail'."\n"; +try { + $fn = Closure::fromCallable('Foo::nonExistentFunction'); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Non-existent class should fail'."\n"; +try { + $fn = Closure::fromCallable(['NonExistentClass', 'foo']); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Non-existent function should fail'."\n"; +try { + $fn = Closure::fromCallable('thisDoesNotExist'); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + + +echo 'Subclass cannot closure over parent private instance method'."\n"; +try { + $subFoo = new SubFoo; + $fn = $subFoo->closePrivateInvalid(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Subclass cannot closure over parant private static method'."\n"; +try { + $subFoo = new SubFoo; + $fn = $subFoo->closePrivateStaticInvalid(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Function scope cannot closure over protected instance method'."\n"; +try { + $fn = functionAccessProtected(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Function scope cannot closure over private instance method'."\n"; +try { + $fn = functionAccessPrivate(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo 'Access private instance method of parent object through "self::" to parent method'."\n"; +try { + $foo = new SubFoo; + $fn = $foo->getSelfColonParentPrivateInstanceMethod(); + echo "Test failed to fail, closure is : ".var_export($fn, true)."\n"; +} +catch (\TypeError $te) { + //This is the expected outcome. +} +catch (\Throwable $t) { + echo "Wrong exception type thrown: ".get_class($t)." : ".$t->getMessage()."\n"; +} + +echo "OK\n"; + +?> +===DONE=== +--EXPECT-- + +Cannot access privateInstance method statically +Cannot access privateInstance method statically with colon scheme +Cannot access privateInstance method +SubClass cannot access private instance method +Cannot access private static function of instance +Cannot access private static method statically +Cannot access private static method statically with colon scheme +Non-existent method should fail +Non-existent class should fail +Non-existent function should fail +Subclass cannot closure over parent private instance method +Subclass cannot closure over parant private static method +Function scope cannot closure over protected instance method +Function scope cannot closure over private instance method +Access private instance method of parent object through "self::" to parent method +OK +===DONE=== diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index 810ac6a..adf5981 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -235,6 +235,105 @@ ZEND_METHOD(Closure, bind) } /* }}} */ +static void zend_closure_call_magic(INTERNAL_FUNCTION_PARAMETERS) { + zend_fcall_info fci; + zend_fcall_info_cache fcc; + + memset(&fci, 0, sizeof(zend_fcall_info)); + memset(&fci, 0, sizeof(zend_fcall_info_cache)); + + fci.size = sizeof(zend_fcall_info); + fci.retval = return_value; + + fcc.initialized = 1; + fcc.function_handler = (zend_function *) EX(func)->common.arg_info; + fci.params = (zval*) emalloc(sizeof(zval) * 2); + fci.param_count = 2; + ZVAL_STR(&fci.params[0], EX(func)->common.function_name); + array_init(&fci.params[1]); + zend_copy_parameters_array(ZEND_NUM_ARGS(), &fci.params[1]); + + fci.object = Z_OBJ(EX(This)); + fcc.object = Z_OBJ(EX(This)); + fcc.calling_scope = zend_get_executed_scope(); + + zend_call_function(&fci, &fcc); + + zval_ptr_dtor(&fci.params[0]); + zval_ptr_dtor(&fci.params[1]); + efree(fci.params); +} + + +static int zend_create_closure_from_callable(zval *return_value, zval *callable, char **error) { + zend_fcall_info_cache fcc; + zend_function *mptr; + zval instance; + + if (!zend_is_callable_ex(callable, NULL, 0, NULL, &fcc, error)) { + return FAILURE; + } + + mptr = fcc.function_handler; + if (mptr == NULL) { + return FAILURE; + } + + if (mptr->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) { + zend_internal_function call; + memset(&call, 0, sizeof(zend_internal_function)); + + call.type = ZEND_INTERNAL_FUNCTION; + call.handler = zend_closure_call_magic; + call.function_name = mptr->common.function_name; + call.arg_info = (zend_internal_arg_info *) mptr->common.prototype; + call.scope = mptr->common.scope; + + zend_free_trampoline(mptr); + mptr = (zend_function *) &call; + } + + ZVAL_OBJ(&instance, fcc.object); + zend_create_closure(return_value, mptr, mptr->common.scope, fcc.object ? fcc.object->ce : NULL, fcc.object ? &instance : NULL); + + return SUCCESS; +} + + +/* {{{ proto Closure Closure::fromCallable(callable callable) + Create a closure from a callabl using the current scope. */ +ZEND_METHOD(Closure, fromCallable) +{ + zval *callable; + int success; + char *error = NULL; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &callable) == FAILURE) { + return; + } + + if (Z_TYPE_P(callable) == IS_OBJECT && instanceof_function(Z_OBJCE_P(callable), zend_ce_closure)) { + // It's already a closure + RETURN_ZVAL(callable, 1, 0); + } + + // create closure as if it were called from parent scope + EG(current_execute_data) = EX(prev_execute_data); + success = zend_create_closure_from_callable(return_value, callable, &error); + EG(current_execute_data) = execute_data; + + if (success == FAILURE) { + zend_clear_exception(); + if (error) { + zend_throw_exception_ex(zend_ce_type_error, 0, "Failed to create closure from callable: %s", error); + efree(error); + } else { + zend_throw_exception_ex(zend_ce_type_error, 0, "Failed to create closure from callable"); + } + } +} +/* }}} */ + static ZEND_COLD zend_function *zend_closure_get_constructor(zend_object *object) /* {{{ */ { zend_throw_error(NULL, "Instantiation of 'Closure' is not allowed"); @@ -489,11 +588,16 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_call, 0, 0, 1) ZEND_ARG_VARIADIC_INFO(0, parameters) ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_fromcallable, 0, 0, 1) + ZEND_ARG_INFO(0, newthis) +ZEND_END_ARG_INFO() + static const zend_function_entry closure_functions[] = { ZEND_ME(Closure, __construct, NULL, ZEND_ACC_PRIVATE) ZEND_ME(Closure, bind, arginfo_closure_bind, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) ZEND_MALIAS(Closure, bindTo, bind, arginfo_closure_bindto, ZEND_ACC_PUBLIC) ZEND_ME(Closure, call, arginfo_closure_call, ZEND_ACC_PUBLIC) + ZEND_ME(Closure, fromCallable, arginfo_closure_fromcallable, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) ZEND_FE_END }; diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 13003ca..ac6c00d 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -1633,6 +1633,30 @@ ZEND_METHOD(reflection_function, export) } /* }}} */ + +static zend_function *_find_function_pointer(char *name_str, int name_len) { + char *lcname, *nsname; + zend_function *fptr; + + lcname = zend_str_tolower_dup(name_str, name_len); + + /* Ignore leading "\" */ + nsname = lcname; + if (lcname[0] == '\\') { + nsname = &lcname[1]; + name_len--; + } + + if ((fptr = zend_hash_str_find_ptr(EG(function_table), nsname, name_len)) == NULL) { + efree(lcname); + return NULL; + } + efree(lcname); + + return fptr; +} + + /* {{{ proto public void ReflectionFunction::__construct(string name) Constructor. Throws an Exception in case the given function does not exist */ ZEND_METHOD(reflection_function, __construct) @@ -1656,23 +1680,12 @@ ZEND_METHOD(reflection_function, __construct) if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { return; } - - lcname = zend_str_tolower_dup(name_str, name_len); - - /* Ignore leading "\" */ - nsname = lcname; - if (lcname[0] == '\\') { - nsname = &lcname[1]; - name_len--; - } - - if ((fptr = zend_hash_str_find_ptr(EG(function_table), nsname, name_len)) == NULL) { - efree(lcname); + fptr = _find_function_pointer(name_str, name_len); + if (fptr == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Function %s() does not exist", name_str); - return; + return; } - efree(lcname); } ZVAL_STR_COPY(&name, fptr->common.function_name); @@ -6793,6 +6806,10 @@ static const zend_function_entry reflection_zend_extension_functions[] = { }; /* }}} */ +ZEND_BEGIN_ARG_INFO_EX(arginfo_closure, 0, 0, 1) + ZEND_ARG_INFO(0, callable) +ZEND_END_ARG_INFO() + const zend_function_entry reflection_ext_functions[] = { /* {{{ */ PHP_FE_END }; /* }}} */