<form method="POST">
    <h3>Editing: CompletionInput.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\Completion;

use Symfony\Component\Console\Exception\RuntimeException;
use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\InputOption;

/**
 * An input specialized for shell completion.
 *
 * This input allows unfinished option names or values and exposes what kind of
 * completion is expected.
 *
 * @author Wouter de Jong &lt;wouter@wouterj.nl&gt;
 */
final class CompletionInput extends ArgvInput
{
    public const TYPE_ARGUMENT_VALUE = 'argument_value';
    public const TYPE_OPTION_VALUE = 'option_value';
    public const TYPE_OPTION_NAME = 'option_name';
    public const TYPE_NONE = 'none';

    private $tokens;
    private $currentIndex;
    private $completionType;
    private $completionName = null;
    private $completionValue = '';

    /**
     * Converts a terminal string into tokens.
     *
     * This is required for shell completions without COMP_WORDS support.
     */
    public static function fromString(string $inputStr, int $currentIndex): self
    {
        preg_match_all('/(?&lt;=^|\s)([\'&quot;]?)(.+?)(?&lt;!\\\\)\1(?=$|\s)/', $inputStr, $tokens);

        return self::fromTokens($tokens[0], $currentIndex);
    }

    /**
     * Create an input based on an COMP_WORDS token list.
     *
     * @param string[] $tokens       the set of split tokens (e.g. COMP_WORDS or argv)
     * @param          $currentIndex the index of the cursor (e.g. COMP_CWORD)
     */
    public static function fromTokens(array $tokens, int $currentIndex): self
    {
        $input = new self($tokens);
        $input-&gt;tokens = $tokens;
        $input-&gt;currentIndex = $currentIndex;

        return $input;
    }

    /**
     * {@inheritdoc}
     */
    public function bind(InputDefinition $definition): void
    {
        parent::bind($definition);

        $relevantToken = $this-&gt;getRelevantToken();
        if ('-' === $relevantToken[0]) {
            // the current token is an input option: complete either option name or option value
            [$optionToken, $optionValue] = explode('=', $relevantToken, 2) + ['', ''];

            $option = $this-&gt;getOptionFromToken($optionToken);
            if (null === $option &amp;&amp; !$this-&gt;isCursorFree()) {
                $this-&gt;completionType = self::TYPE_OPTION_NAME;
                $this-&gt;completionValue = $relevantToken;

                return;
            }

            if (null !== $option &amp;&amp; $option-&gt;acceptValue()) {
                $this-&gt;completionType = self::TYPE_OPTION_VALUE;
                $this-&gt;completionName = $option-&gt;getName();
                $this-&gt;completionValue = $optionValue ?: (!str_starts_with($optionToken, '--') ? substr($optionToken, 2) : '');

                return;
            }
        }

        $previousToken = $this-&gt;tokens[$this-&gt;currentIndex - 1];
        if ('-' === $previousToken[0] &amp;&amp; '' !== trim($previousToken, '-')) {
            // check if previous option accepted a value
            $previousOption = $this-&gt;getOptionFromToken($previousToken);
            if (null !== $previousOption &amp;&amp; $previousOption-&gt;acceptValue()) {
                $this-&gt;completionType = self::TYPE_OPTION_VALUE;
                $this-&gt;completionName = $previousOption-&gt;getName();
                $this-&gt;completionValue = $relevantToken;

                return;
            }
        }

        // complete argument value
        $this-&gt;completionType = self::TYPE_ARGUMENT_VALUE;

        foreach ($this-&gt;definition-&gt;getArguments() as $argumentName =&gt; $argument) {
            if (!isset($this-&gt;arguments[$argumentName])) {
                break;
            }

            $argumentValue = $this-&gt;arguments[$argumentName];
            $this-&gt;completionName = $argumentName;
            if (\is_array($argumentValue)) {
                $this-&gt;completionValue = $argumentValue ? $argumentValue[array_key_last($argumentValue)] : null;
            } else {
                $this-&gt;completionValue = $argumentValue;
            }
        }

        if ($this-&gt;currentIndex &gt;= \count($this-&gt;tokens)) {
            if (!isset($this-&gt;arguments[$argumentName]) || $this-&gt;definition-&gt;getArgument($argumentName)-&gt;isArray()) {
                $this-&gt;completionName = $argumentName;
                $this-&gt;completionValue = '';
            } else {
                // we've reached the end
                $this-&gt;completionType = self::TYPE_NONE;
                $this-&gt;completionName = null;
                $this-&gt;completionValue = '';
            }
        }
    }

    /**
     * Returns the type of completion required.
     *
     * TYPE_ARGUMENT_VALUE when completing the value of an input argument
     * TYPE_OPTION_VALUE   when completing the value of an input option
     * TYPE_OPTION_NAME    when completing the name of an input option
     * TYPE_NONE           when nothing should be completed
     *
     * @return string One of self::TYPE_* constants. TYPE_OPTION_NAME and TYPE_NONE are already implemented by the Console component
     */
    public function getCompletionType(): string
    {
        return $this-&gt;completionType;
    }

    /**
     * The name of the input option or argument when completing a value.
     *
     * @return string|null returns null when completing an option name
     */
    public function getCompletionName(): ?string
    {
        return $this-&gt;completionName;
    }

    /**
     * The value already typed by the user (or empty string).
     */
    public function getCompletionValue(): string
    {
        return $this-&gt;completionValue;
    }

    public function mustSuggestOptionValuesFor(string $optionName): bool
    {
        return self::TYPE_OPTION_VALUE === $this-&gt;getCompletionType() &amp;&amp; $optionName === $this-&gt;getCompletionName();
    }

    public function mustSuggestArgumentValuesFor(string $argumentName): bool
    {
        return self::TYPE_ARGUMENT_VALUE === $this-&gt;getCompletionType() &amp;&amp; $argumentName === $this-&gt;getCompletionName();
    }

    protected function parseToken(string $token, bool $parseOptions): bool
    {
        try {
            return parent::parseToken($token, $parseOptions);
        } catch (RuntimeException $e) {
            // suppress errors, completed input is almost never valid
        }

        return $parseOptions;
    }

    private function getOptionFromToken(string $optionToken): ?InputOption
    {
        $optionName = ltrim($optionToken, '-');
        if (!$optionName) {
            return null;
        }

        if ('-' === ($optionToken[1] ?? ' ')) {
            // long option name
            return $this-&gt;definition-&gt;hasOption($optionName) ? $this-&gt;definition-&gt;getOption($optionName) : null;
        }

        // short option name
        return $this-&gt;definition-&gt;hasShortcut($optionName[0]) ? $this-&gt;definition-&gt;getOptionForShortcut($optionName[0]) : null;
    }

    /**
     * The token of the cursor, or the last token if the cursor is at the end of the input.
     */
    private function getRelevantToken(): string
    {
        return $this-&gt;tokens[$this-&gt;isCursorFree() ? $this-&gt;currentIndex - 1 : $this-&gt;currentIndex];
    }

    /**
     * Whether the cursor is &quot;free&quot; (i.e. at the end of the input preceded by a space).
     */
    private function isCursorFree(): bool
    {
        $nrOfTokens = \count($this-&gt;tokens);
        if ($this-&gt;currentIndex &gt; $nrOfTokens) {
            throw new \LogicException('Current index is invalid, it must be the number of input tokens or one more.');
        }

        return $this-&gt;currentIndex &gt;= $nrOfTokens;
    }

    public function __toString()
    {
        $str = '';
        foreach ($this-&gt;tokens as $i =&gt; $token) {
            $str .= $token;

            if ($this-&gt;currentIndex === $i) {
                $str .= '|';
            }

            $str .= ' ';
        }

        if ($this-&gt;currentIndex &gt; $i) {
            $str .= '|';
        }

        return rtrim($str);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>