Add ReflectionFunctionAbstract::getParameter() and hasParameter()

ext/reflection/php_reflection.c

@@ -1519,6 +1519,28 @@ static int get_parameter_default(zval *result, parameter_reference *param) {
 	}
 }
 
+static zend_long get_parameter_position(zend_function *func, zend_string* arg_name, uint32_t num_args) {
+    struct _zend_arg_info *arg_info = func->common.arg_info;
+    uint32_t i;
+    bool internal = has_internal_arg_info(func);
+
+    for (i = 0; i < num_args; i++) {
+        if (arg_info[i].name) {
+            if (internal) {
+                if (strcmp(((zend_internal_arg_info*)arg_info)[i].name, ZSTR_VAL(arg_name)) == 0) {
+                    return i;
+                }
+            } else {
+                if (zend_string_equals(arg_name, arg_info[i].name)) {
+                    return i;
+                }
+            }
+        }
+    }
+
+    return -1;
+}
+
 /* {{{ Preventing __clone from being called */
 ZEND_METHOD(ReflectionClass, __clone)
 {
@@ -2105,7 +2127,122 @@ ZEND_METHOD(ReflectionFunctionAbstract, getNumberOfRequiredParameters)
 }
 /* }}} */
 
-/* {{{ Returns an array of parameter objects for this function */
+/* {{{ Returns whether a parameter exists or not */
+ZEND_METHOD(ReflectionFunctionAbstract, hasParameter)
+{
+    reflection_object *intern;
+    zend_function *fptr;
+    zend_string *arg_name = NULL;
+    zend_long position;
+    uint32_t num_args;
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+        Z_PARAM_STR_OR_LONG(arg_name, position)
+    ZEND_PARSE_PARAMETERS_END();
+
+    GET_REFLECTION_OBJECT_PTR(fptr);
+
+    num_args = fptr->common.num_args;
+
+    if (fptr->common.fn_flags & ZEND_ACC_VARIADIC) {
+        num_args++;
+    }
+
+    if (!num_args) {
+        RETURN_FALSE;
+    }
+
+    if (arg_name != NULL) {
+        if (ZSTR_LEN(arg_name) == 0) {
+            zend_argument_value_error(1, "must not be an empty string");
+            RETURN_THROWS();
+        }
+
+        if (get_parameter_position(fptr, arg_name, num_args) > -1) {
+            RETURN_TRUE;
+        }
+
+        RETURN_FALSE;
+    } else {
+        position -= 1;
+
+        if (position < 0) {
+            zend_argument_value_error(1, "must be greater than or equal to 1");
+            RETURN_THROWS();
+        }
+
+        RETURN_BOOL(position < num_args);
+    }
+}
+/* }}} */
+
+/* {{{ Returns a parameter specified by its name */
+ZEND_METHOD(ReflectionFunctionAbstract, getParameter)
+{
+    reflection_object *intern;
+    zend_function *fptr;
+    zend_string *arg_name = NULL;
+    zend_long position;
+    struct _zend_arg_info *arg_info;
+    uint32_t num_args;
+    zval reflection;
+
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+        Z_PARAM_STR_OR_LONG(arg_name, position)
+    ZEND_PARSE_PARAMETERS_END();
+
+    GET_REFLECTION_OBJECT_PTR(fptr);
+
+    num_args = fptr->common.num_args;
+    arg_info = fptr->common.arg_info;
+
+    if (fptr->common.fn_flags & ZEND_ACC_VARIADIC) {
+        num_args++;
+    }
+
+    if (!num_args) {
+        RETURN_THROWS();
+    }
+
+    if (arg_name != NULL) {
+        if (ZSTR_LEN(arg_name) == 0) {
+            zend_argument_value_error(1, "must not be an empty string");
+            RETURN_THROWS();
+        }
+
+        position = get_parameter_position(fptr, arg_name, num_args);
+
+        if (position == -1) {
+            _DO_THROW("The parameter specified by its name could not be found");
+            RETURN_THROWS();
+        }
+    } else {
+        position -= 1;
+
+        if (position < 0) {
+            zend_argument_value_error(1, "must be greater than or equal to 1");
+            RETURN_THROWS();
+        }
+        if (position >= num_args) {
+            _DO_THROW("The parameter specified by its offset could not be found");
+            RETURN_THROWS();
+        }
+    }
+
+    reflection_parameter_factory(
+        _copy_function(fptr),
+        Z_ISUNDEF(intern->obj) ? NULL : &intern->obj,
+        &arg_info[position],
+        position,
+        position < fptr->common.required_num_args,
+        &reflection
+    );
+
+    RETURN_OBJ(Z_OBJ(reflection));
+}
+/* }}} */
+
+/* {{{ Returns the function/method specified by its name */
 ZEND_METHOD(ReflectionFunctionAbstract, getParameters)
 {
 	reflection_object *intern;

ext/reflection/php_reflection.stub.php

@@ -112,6 +112,10 @@ public function hasTentativeReturnType(): bool {}
     public function getTentativeReturnType(): ?ReflectionType {}
 
     public function getAttributes(?string $name = null, int $flags = 0): array {}
+
+    public function hasParameter(int|string $parameter): bool;
+
+    public function getParameter(int|string $parameter): ReflectionParameter;
 }
 
 class ReflectionFunction extends ReflectionFunctionAbstract

ext/reflection/tests/ReflectionFunction_getParameter_basic.phpt

@@ -0,0 +1,41 @@
+--TEST--
+ReflectionFunction::getParameter()
+--FILE--
+<?php
+function foo(string $bar) {}
+
+$function = new ReflectionFunction('sort');
+var_dump($function->getParameter('array'));
+var_dump($function->getParameter('flags'));
+var_dump($function->getParameter(1));
+var_dump($function->getParameter(2));
+
+$function = new ReflectionFunction('foo');
+var_dump($function->getParameter('bar'));
+var_dump($function->getParameter(1));
+?>
+--EXPECT--
+object(ReflectionParameter)#2 (1) {
+  ["name"]=>
+  string(5) "array"
+}
+object(ReflectionParameter)#2 (1) {
+  ["name"]=>
+  string(5) "flags"
+}
+object(ReflectionParameter)#2 (1) {
+  ["name"]=>
+  string(5) "array"
+}
+object(ReflectionParameter)#2 (1) {
+  ["name"]=>
+  string(5) "flags"
+}
+object(ReflectionParameter)#1 (1) {
+  ["name"]=>
+  string(3) "bar"
+}
+object(ReflectionParameter)#1 (1) {
+  ["name"]=>
+  string(3) "bar"
+}

ext/reflection/tests/ReflectionFunction_getParameter_error.phpt

@@ -0,0 +1,53 @@
+--TEST--
+ReflectionFunction::getParameter() errors
+--FILE--
+<?php
+$function = new ReflectionFunction('sort');
+function foo(string $bar) {}
+
+try {
+    var_dump($function->getParameter('Array'));
+} catch(ReflectionException $e) {
+    print($e->getMessage() . PHP_EOL);
+}
+
+try {
+    var_dump($function->getParameter(-1));
+} catch(ValueError $e) {
+    print($e->getMessage() . PHP_EOL);
+}
+
+try {
+    var_dump($function->getParameter(3));
+} catch(ReflectionException $e) {
+    print($e->getMessage() . PHP_EOL);
+}
+
+$function = new ReflectionFunction('foo');
+
+try {
+    var_dump($function->getParameter('Bar'));
+} catch(ReflectionException $e) {
+    print($e->getMessage() . PHP_EOL);
+}
+
+try {
+    var_dump($function->getParameter(-1));
+} catch(ValueError $e) {
+    print($e->getMessage() . PHP_EOL);
+}
+
+try {
+    var_dump($function->getParameter(2));
+} catch(ReflectionException $e) {
+    print($e->getMessage() . PHP_EOL);
+}
+
+?>
+--EXPECT--
+The parameter specified by its name could not be found
+ReflectionFunctionAbstract::getParameter(): Argument #1 ($parameter) must be greater than or equal to 1
+The parameter specified by its offset could not be found
+The parameter specified by its name could not be found
+ReflectionFunctionAbstract::getParameter(): Argument #1 ($parameter) must be greater than or equal to 1
+The parameter specified by its offset could not be found

ext/reflection/tests/ReflectionFunction_hasParameter_basic.phpt

@@ -0,0 +1,31 @@
+--TEST--
+ReflectionFunction::hasParameter()
+--FILE--
+<?php
+function foo(string $bar) {}
+
+$function = new ReflectionFunction('sort');
+var_dump($function->hasParameter('array'));
+var_dump($function->hasParameter('Array'));
+var_dump($function->hasParameter('string'));
+var_dump($function->hasParameter(1));
+var_dump($function->hasParameter(2));
+
+$function = new ReflectionFunction('foo');
+var_dump($function->hasParameter('bar'));
+var_dump($function->hasParameter('Bar'));
+var_dump($function->hasParameter('string'));
+var_dump($function->hasParameter(1));
+var_dump($function->hasParameter(2));
+?>
+--EXPECT--
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)

ext/reflection/tests/ReflectionFunction_hasParameter_error.phpt

@@ -0,0 +1,25 @@
+--TEST--
+ReflectionFunction::hasParameter() errors
+--FILE--
+<?php
+function foo(string $bar) {}
+
+$function = new ReflectionFunction('sort');
+
+try {
+    var_dump($function->hasParameter(-1));
+} catch (ValueError $e) {
+    print($e->getMessage() . PHP_EOL);
+}
+
+$function = new ReflectionFunction('foo');
+
+try {
+    var_dump($function->hasParameter(-1));
+} catch (ValueError $e) {
+    print($e->getMessage() . PHP_EOL);
+}
+?>
+--EXPECT--
+ReflectionFunctionAbstract::hasParameter(): Argument #1 ($parameter) must be greater than or equal to 1
+ReflectionFunctionAbstract::hasParameter(): Argument #1 ($parameter) must be greater than or equal to 1

ext/reflection/tests/ReflectionMethod_getParameter_basic.phpt

@@ -0,0 +1,33 @@
+--TEST--
+ReflectionMethod::getParameter()
+--FILE--
+<?php
+class C {
+    public function foo(string $bar) {}
+}
+
+$method = new ReflectionMethod('WeakReference', 'create');
+var_dump($method->getParameter('object'));
+var_dump($method->getParameter(1));
+
+$method = new ReflectionMethod('C', 'foo');
+var_dump($method->getParameter('bar'));
+var_dump($method->getParameter(1));
+?>
+--EXPECT--
+object(ReflectionParameter)#2 (1) {
+  ["name"]=>
+  string(6) "object"
+}
+object(ReflectionParameter)#2 (1) {
+  ["name"]=>
+  string(6) "object"
+}
+object(ReflectionParameter)#1 (1) {
+  ["name"]=>
+  string(3) "bar"
+}
+object(ReflectionParameter)#1 (1) {
+  ["name"]=>
+  string(3) "bar"
+}