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

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Console\Command;

use Symfony\Component\Console\Completion\CompletionInput;
use Symfony\Component\Console\Completion\CompletionSuggestions;
use Symfony\Component\Console\Completion\Output\BashCompletionOutput;
use Symfony\Component\Console\Completion\Output\CompletionOutputInterface;
use Symfony\Component\Console\Exception\CommandNotFoundException;
use Symfony\Component\Console\Exception\ExceptionInterface;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Responsible for providing the values to the shell completion.
 *
 * @author Wouter de Jong &lt;wouter@wouterj.nl&gt;
 */
final class CompleteCommand extends Command
{
    protected static $defaultName = '|_complete';
    protected static $defaultDescription = 'Internal command to provide shell completion suggestions';

    private $completionOutputs;

    private $isDebug = false;

    /**
     * @param array&lt;string, class-string&lt;CompletionOutputInterface&gt;&gt; $completionOutputs A list of additional completion outputs, with shell name as key and FQCN as value
     */
    public function __construct(array $completionOutputs = [])
    {
        // must be set before the parent constructor, as the property value is used in configure()
        $this-&gt;completionOutputs = $completionOutputs + ['bash' =&gt; BashCompletionOutput::class];

        parent::__construct();
    }

    protected function configure(): void
    {
        $this
            -&gt;addOption('shell', 's', InputOption::VALUE_REQUIRED, 'The shell type (&quot;'.implode('&quot;, &quot;', array_keys($this-&gt;completionOutputs)).'&quot;)')
            -&gt;addOption('input', 'i', InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY, 'An array of input tokens (e.g. COMP_WORDS or argv)')
            -&gt;addOption('current', 'c', InputOption::VALUE_REQUIRED, 'The index of the &quot;input&quot; array that the cursor is in (e.g. COMP_CWORD)')
            -&gt;addOption('symfony', 'S', InputOption::VALUE_REQUIRED, 'The version of the completion script')
        ;
    }

    protected function initialize(InputInterface $input, OutputInterface $output)
    {
        $this-&gt;isDebug = filter_var(getenv('SYMFONY_COMPLETION_DEBUG'), \FILTER_VALIDATE_BOOLEAN);
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        try {
            // uncomment when a bugfix or BC break has been introduced in the shell completion scripts
            // $version = $input-&gt;getOption('symfony');
            // if ($version &amp;&amp; version_compare($version, 'x.y', '&gt;=')) {
            //    $message = sprintf('Completion script version is not supported (&quot;%s&quot; given, &quot;&gt;=x.y&quot; required).', $version);
            //    $this-&gt;log($message);

            //    $output-&gt;writeln($message.' Install the Symfony completion script again by using the &quot;completion&quot; command.');

            //    return 126;
            // }

            $shell = $input-&gt;getOption('shell');
            if (!$shell) {
                throw new \RuntimeException('The &quot;--shell&quot; option must be set.');
            }

            if (!$completionOutput = $this-&gt;completionOutputs[$shell] ?? false) {
                throw new \RuntimeException(sprintf('Shell completion is not supported for your shell: &quot;%s&quot; (supported: &quot;%s&quot;).', $shell, implode('&quot;, &quot;', array_keys($this-&gt;completionOutputs))));
            }

            $completionInput = $this-&gt;createCompletionInput($input);
            $suggestions = new CompletionSuggestions();

            $this-&gt;log([
                '',
                '&lt;comment&gt;'.date('Y-m-d H:i:s').'&lt;/&gt;',
                '&lt;info&gt;Input:&lt;/&gt; &lt;comment&gt;(&quot;|&quot; indicates the cursor position)&lt;/&gt;',
                '  '.(string) $completionInput,
                '&lt;info&gt;Command:&lt;/&gt;',
                '  '.(string) implode(' ', $_SERVER['argv']),
                '&lt;info&gt;Messages:&lt;/&gt;',
            ]);

            $command = $this-&gt;findCommand($completionInput, $output);
            if (null === $command) {
                $this-&gt;log('  No command found, completing using the Application class.');

                $this-&gt;getApplication()-&gt;complete($completionInput, $suggestions);
            } elseif (
                $completionInput-&gt;mustSuggestArgumentValuesFor('command')
                &amp;&amp; $command-&gt;getName() !== $completionInput-&gt;getCompletionValue()
                &amp;&amp; !\in_array($completionInput-&gt;getCompletionValue(), $command-&gt;getAliases(), true)
            ) {
                $this-&gt;log('  No command found, completing using the Application class.');

                // expand shortcut names (&quot;cache:cl&lt;TAB&gt;&quot;) into their full name (&quot;cache:clear&quot;)
                $suggestions-&gt;suggestValues(array_filter(array_merge([$command-&gt;getName()], $command-&gt;getAliases())));
            } else {
                $command-&gt;mergeApplicationDefinition();
                $completionInput-&gt;bind($command-&gt;getDefinition());

                if (CompletionInput::TYPE_OPTION_NAME === $completionInput-&gt;getCompletionType()) {
                    $this-&gt;log('  Completing option names for the &lt;comment&gt;'.\get_class($command instanceof LazyCommand ? $command-&gt;getCommand() : $command).'&lt;/&gt; command.');

                    $suggestions-&gt;suggestOptions($command-&gt;getDefinition()-&gt;getOptions());
                } else {
                    $this-&gt;log([
                        '  Completing using the &lt;comment&gt;'.\get_class($command instanceof LazyCommand ? $command-&gt;getCommand() : $command).'&lt;/&gt; class.',
                        '  Completing &lt;comment&gt;'.$completionInput-&gt;getCompletionType().'&lt;/&gt; for &lt;comment&gt;'.$completionInput-&gt;getCompletionName().'&lt;/&gt;',
                    ]);
                    if (null !== $compval = $completionInput-&gt;getCompletionValue()) {
                        $this-&gt;log('  Current value: &lt;comment&gt;'.$compval.'&lt;/&gt;');
                    }

                    $command-&gt;complete($completionInput, $suggestions);
                }
            }

            /** @var CompletionOutputInterface $completionOutput */
            $completionOutput = new $completionOutput();

            $this-&gt;log('&lt;info&gt;Suggestions:&lt;/&gt;');
            if ($options = $suggestions-&gt;getOptionSuggestions()) {
                $this-&gt;log('  --'.implode(' --', array_map(function ($o) { return $o-&gt;getName(); }, $options)));
            } elseif ($values = $suggestions-&gt;getValueSuggestions()) {
                $this-&gt;log('  '.implode(' ', $values));
            } else {
                $this-&gt;log('  &lt;comment&gt;No suggestions were provided&lt;/&gt;');
            }

            $completionOutput-&gt;write($suggestions, $output);
        } catch (\Throwable $e) {
            $this-&gt;log([
                '&lt;error&gt;Error!&lt;/error&gt;',
                (string) $e,
            ]);

            if ($output-&gt;isDebug()) {
                throw $e;
            }

            return 2;
        }

        return 0;
    }

    private function createCompletionInput(InputInterface $input): CompletionInput
    {
        $currentIndex = $input-&gt;getOption('current');
        if (!$currentIndex || !ctype_digit($currentIndex)) {
            throw new \RuntimeException('The &quot;--current&quot; option must be set and it must be an integer.');
        }

        $completionInput = CompletionInput::fromTokens($input-&gt;getOption('input'), (int) $currentIndex);

        try {
            $completionInput-&gt;bind($this-&gt;getApplication()-&gt;getDefinition());
        } catch (ExceptionInterface $e) {
        }

        return $completionInput;
    }

    private function findCommand(CompletionInput $completionInput, OutputInterface $output): ?Command
    {
        try {
            $inputName = $completionInput-&gt;getFirstArgument();
            if (null === $inputName) {
                return null;
            }

            return $this-&gt;getApplication()-&gt;find($inputName);
        } catch (CommandNotFoundException $e) {
        }

        return null;
    }

    private function log($messages): void
    {
        if (!$this-&gt;isDebug) {
            return;
        }

        $commandName = basename($_SERVER['argv'][0]);
        file_put_contents(sys_get_temp_dir().'/sf_'.$commandName.'.log', implode(\PHP_EOL, (array) $messages).\PHP_EOL, \FILE_APPEND);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>