<form method="POST">
    <h3>Editing: FactoryParameter.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 Copyright (c) 2009 hamcrest.org
 */

class FactoryParameter
{
    /**
     * @var FactoryMethod
     */
    private $method;

    /**
     * @var ReflectionParameter
     */
    private $reflector;

    public function __construct(FactoryMethod $method, ReflectionParameter $reflector)
    {
        $this-&gt;method = $method;
        $this-&gt;reflector = $reflector;
    }

    /**
     * Compute the declaration code.
     *
     * @return string
     */
    public function getDeclaration()
    {
        $code = $this-&gt;getTypeCode() . $this-&gt;getInvocation();

        if ($this-&gt;reflector-&gt;isOptional()) {
            $default = $this-&gt;reflector-&gt;getDefaultValue();
            if (is_null($default)) {
                $default = 'null';
            } elseif (is_bool($default)) {
                $default = $default ? 'true' : 'false';
            } elseif (is_string($default)) {
                $default = &quot;'&quot; . $default . &quot;'&quot;;
            } elseif (is_numeric($default)) {
                $default = strval($default);
            } elseif (is_array($default)) {
                $default = 'array()';
            } else {
                echo 'Warning: unknown default type for ' . $this-&gt;getMethod()-&gt;getFullName() . &quot;\n&quot;;
                var_dump($default);
                $default = 'null';
            }
            $code .= ' = ' . $default;
        }
        return $code;
    }

    /**
     * Compute the type code for the paramater.
     *
     * @return string
     */
    private function getTypeCode()
    {
        // Handle PHP 5 separately
        if (PHP_VERSION_ID &lt; 70000) {
            if ($this-&gt;reflector-&gt;isArray()) {
                return 'array';
            }

            $class = $this-&gt;reflector-&gt;getClass();

            return $class ? sprintf('\\%s ', $class-&gt;getName()) : '';
        }

        if (!$this-&gt;reflector-&gt;hasType()) {
            return '';
        }

        $type = $this-&gt;reflector-&gt;getType();
        $name = self::getQualifiedName($type);

        // PHP 7.1+ supports nullable types via a leading question mark
        return (PHP_VERSION_ID &gt;= 70100 &amp;&amp; $type-&gt;allowsNull()) ? sprintf('?%s ', $name) : sprintf('%s ', $name);
    }

    /**
     * Compute qualified name for the given type.
     *
     * This function knows how to prefix class names with a leading slash and
     * also how to handle PHP 8's union types.
     *
     * @param ReflectionType $type
     *
     * @return string
     */
    private static function getQualifiedName(ReflectionType $type)
    {
        // PHP 8 union types can be recursively processed
        if ($type instanceof ReflectionUnionType) {
            return implode('|', array_map(function (ReflectionType $type) {
                // The &quot;self::&quot; call within a Closure is fine here because this
                // code will only ever be executed on PHP 7.0+
                return self::getQualifiedName($type);
            }, $type-&gt;getTypes()));
        }

        // PHP 7.0 doesn't have named types, but 7.1+ does
        $name = $type instanceof ReflectionNamedType ? $type-&gt;getName() : (string) $type;

        return $type-&gt;isBuiltin() ? $name : sprintf('\\%s', $name);
    }

    /**
     * Compute the invocation code.
     *
     * @return string
     */
    public function getInvocation()
    {
        return sprintf('$%s', $this-&gt;reflector-&gt;getName());
    }

    /**
     * Compute the method name.
     *
     * @return string
     */
    public function getMethod()
    {
        return $this-&gt;method;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>