<form method="POST">
    <h3>Editing: MockMethod.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Framework\MockObject;

use const DIRECTORY_SEPARATOR;
use function explode;
use function implode;
use function is_object;
use function is_string;
use function preg_match;
use function preg_replace;
use function sprintf;
use function strlen;
use function strpos;
use function substr;
use function substr_count;
use function trim;
use function var_export;
use ReflectionMethod;
use ReflectionParameter;
use SebastianBergmann\Template\Exception as TemplateException;
use SebastianBergmann\Template\Template;
use SebastianBergmann\Type\ReflectionMapper;
use SebastianBergmann\Type\Type;
use SebastianBergmann\Type\UnknownType;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class MockMethod
{
    /**
     * @var Template[]
     */
    private static $templates = [];

    /**
     * @var string
     */
    private $className;

    /**
     * @var string
     */
    private $methodName;

    /**
     * @var bool
     */
    private $cloneArguments;

    /**
     * @var string string
     */
    private $modifier;

    /**
     * @var string
     */
    private $argumentsForDeclaration;

    /**
     * @var string
     */
    private $argumentsForCall;

    /**
     * @var Type
     */
    private $returnType;

    /**
     * @var string
     */
    private $reference;

    /**
     * @var bool
     */
    private $callOriginalMethod;

    /**
     * @var bool
     */
    private $static;

    /**
     * @var ?string
     */
    private $deprecation;

    /**
     * @throws ReflectionException
     * @throws RuntimeException
     */
    public static function fromReflection(ReflectionMethod $method, bool $callOriginalMethod, bool $cloneArguments): self
    {
        if ($method-&gt;isPrivate()) {
            $modifier = 'private';
        } elseif ($method-&gt;isProtected()) {
            $modifier = 'protected';
        } else {
            $modifier = 'public';
        }

        if ($method-&gt;isStatic()) {
            $modifier .= ' static';
        }

        if ($method-&gt;returnsReference()) {
            $reference = '&amp;';
        } else {
            $reference = '';
        }

        $docComment = $method-&gt;getDocComment();

        if (is_string($docComment) &amp;&amp;
            preg_match('#\*[ \t]*+@deprecated[ \t]*+(.*?)\r?+\n[ \t]*+\*(?:[ \t]*+@|/$)#s', $docComment, $deprecation)) {
            $deprecation = trim(preg_replace('#[ \t]*\r?\n[ \t]*+\*[ \t]*+#', ' ', $deprecation[1]));
        } else {
            $deprecation = null;
        }

        return new self(
            $method-&gt;getDeclaringClass()-&gt;getName(),
            $method-&gt;getName(),
            $cloneArguments,
            $modifier,
            self::getMethodParametersForDeclaration($method),
            self::getMethodParametersForCall($method),
            (new ReflectionMapper)-&gt;fromReturnType($method),
            $reference,
            $callOriginalMethod,
            $method-&gt;isStatic(),
            $deprecation,
        );
    }

    public static function fromName(string $fullClassName, string $methodName, bool $cloneArguments): self
    {
        return new self(
            $fullClassName,
            $methodName,
            $cloneArguments,
            'public',
            '',
            '',
            new UnknownType,
            '',
            false,
            false,
            null,
        );
    }

    public function __construct(string $className, string $methodName, bool $cloneArguments, string $modifier, string $argumentsForDeclaration, string $argumentsForCall, Type $returnType, string $reference, bool $callOriginalMethod, bool $static, ?string $deprecation)
    {
        $this-&gt;className               = $className;
        $this-&gt;methodName              = $methodName;
        $this-&gt;cloneArguments          = $cloneArguments;
        $this-&gt;modifier                = $modifier;
        $this-&gt;argumentsForDeclaration = $argumentsForDeclaration;
        $this-&gt;argumentsForCall        = $argumentsForCall;
        $this-&gt;returnType              = $returnType;
        $this-&gt;reference               = $reference;
        $this-&gt;callOriginalMethod      = $callOriginalMethod;
        $this-&gt;static                  = $static;
        $this-&gt;deprecation             = $deprecation;
    }

    public function getName(): string
    {
        return $this-&gt;methodName;
    }

    /**
     * @throws RuntimeException
     */
    public function generateCode(): string
    {
        if ($this-&gt;static) {
            $templateFile = 'mocked_static_method.tpl';
        } elseif ($this-&gt;returnType-&gt;isNever() || $this-&gt;returnType-&gt;isVoid()) {
            $templateFile = sprintf(
                '%s_method_never_or_void.tpl',
                $this-&gt;callOriginalMethod ? 'proxied' : 'mocked',
            );
        } else {
            $templateFile = sprintf(
                '%s_method.tpl',
                $this-&gt;callOriginalMethod ? 'proxied' : 'mocked',
            );
        }

        $deprecation = $this-&gt;deprecation;

        if (null !== $this-&gt;deprecation) {
            $deprecation         = &quot;The {$this-&gt;className}::{$this-&gt;methodName} method is deprecated ({$this-&gt;deprecation}).&quot;;
            $deprecationTemplate = $this-&gt;getTemplate('deprecation.tpl');

            $deprecationTemplate-&gt;setVar(
                [
                    'deprecation' =&gt; var_export($deprecation, true),
                ],
            );

            $deprecation = $deprecationTemplate-&gt;render();
        }

        $template = $this-&gt;getTemplate($templateFile);

        $template-&gt;setVar(
            [
                'arguments_decl'     =&gt; $this-&gt;argumentsForDeclaration,
                'arguments_call'     =&gt; $this-&gt;argumentsForCall,
                'return_declaration' =&gt; !empty($this-&gt;returnType-&gt;asString()) ? (': ' . $this-&gt;returnType-&gt;asString()) : '',
                'return_type'        =&gt; $this-&gt;returnType-&gt;asString(),
                'arguments_count'    =&gt; !empty($this-&gt;argumentsForCall) ? substr_count($this-&gt;argumentsForCall, ',') + 1 : 0,
                'class_name'         =&gt; $this-&gt;className,
                'method_name'        =&gt; $this-&gt;methodName,
                'modifier'           =&gt; $this-&gt;modifier,
                'reference'          =&gt; $this-&gt;reference,
                'clone_arguments'    =&gt; $this-&gt;cloneArguments ? 'true' : 'false',
                'deprecation'        =&gt; $deprecation,
            ],
        );

        return $template-&gt;render();
    }

    public function getReturnType(): Type
    {
        return $this-&gt;returnType;
    }

    /**
     * @throws RuntimeException
     */
    private function getTemplate(string $template): Template
    {
        $filename = __DIR__ . DIRECTORY_SEPARATOR . 'Generator' . DIRECTORY_SEPARATOR . $template;

        if (!isset(self::$templates[$filename])) {
            try {
                self::$templates[$filename] = new Template($filename);
            } catch (TemplateException $e) {
                throw new RuntimeException(
                    $e-&gt;getMessage(),
                    $e-&gt;getCode(),
                    $e,
                );
            }
        }

        return self::$templates[$filename];
    }

    /**
     * Returns the parameters of a function or method.
     *
     * @throws RuntimeException
     */
    private static function getMethodParametersForDeclaration(ReflectionMethod $method): string
    {
        $parameters = [];
        $types      = (new ReflectionMapper)-&gt;fromParameterTypes($method);

        foreach ($method-&gt;getParameters() as $i =&gt; $parameter) {
            $name = '$' . $parameter-&gt;getName();

            /* Note: PHP extensions may use empty names for reference arguments
             * or &quot;...&quot; for methods taking a variable number of arguments.
             */
            if ($name === '$' || $name === '$...') {
                $name = '$arg' . $i;
            }

            $default         = '';
            $reference       = '';
            $typeDeclaration = '';

            if (!$types[$i]-&gt;type()-&gt;isUnknown()) {
                $typeDeclaration = $types[$i]-&gt;type()-&gt;asString() . ' ';
            }

            if ($parameter-&gt;isPassedByReference()) {
                $reference = '&amp;';
            }

            if ($parameter-&gt;isVariadic()) {
                $name = '...' . $name;
            } elseif ($parameter-&gt;isDefaultValueAvailable()) {
                $default = ' = ' . self::exportDefaultValue($parameter);
            } elseif ($parameter-&gt;isOptional()) {
                $default = ' = null';
            }

            $parameters[] = $typeDeclaration . $reference . $name . $default;
        }

        return implode(', ', $parameters);
    }

    /**
     * Returns the parameters of a function or method.
     *
     * @throws ReflectionException
     */
    private static function getMethodParametersForCall(ReflectionMethod $method): string
    {
        $parameters = [];

        foreach ($method-&gt;getParameters() as $i =&gt; $parameter) {
            $name = '$' . $parameter-&gt;getName();

            /* Note: PHP extensions may use empty names for reference arguments
             * or &quot;...&quot; for methods taking a variable number of arguments.
             */
            if ($name === '$' || $name === '$...') {
                $name = '$arg' . $i;
            }

            if ($parameter-&gt;isVariadic()) {
                continue;
            }

            if ($parameter-&gt;isPassedByReference()) {
                $parameters[] = '&amp;' . $name;
            } else {
                $parameters[] = $name;
            }
        }

        return implode(', ', $parameters);
    }

    /**
     * @throws ReflectionException
     */
    private static function exportDefaultValue(ReflectionParameter $parameter): string
    {
        try {
            $defaultValue = $parameter-&gt;getDefaultValue();

            if (!is_object($defaultValue)) {
                return (string) var_export($defaultValue, true);
            }

            $parameterAsString = $parameter-&gt;__toString();

            return (string) explode(
                ' = ',
                substr(
                    substr(
                        $parameterAsString,
                        strpos($parameterAsString, '&lt;optional&gt; ') + strlen('&lt;optional&gt; '),
                    ),
                    0,
                    -2,
                ),
            )[1];
            // @codeCoverageIgnoreStart
        } catch (\ReflectionException $e) {
            throw new ReflectionException(
                $e-&gt;getMessage(),
                $e-&gt;getCode(),
                $e,
            );
        }
        // @codeCoverageIgnoreEnd
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>