function ResolveInstanceofConditionalsPass::processDefinition

1 call to ResolveInstanceofConditionalsPass::processDefinition()

ResolveInstanceofConditionalsPass::process in vendor/symfony/dependency-injection/Compiler/ResolveInstanceofConditionalsPass.php

You can modify the container here before it is dumped to PHP code.

File

vendor/symfony/dependency-injection/Compiler/ResolveInstanceofConditionalsPass.php, line 50

Class

ResolveInstanceofConditionalsPass

Applies instanceof conditionals to definitions.

Namespace

Symfony\Component\DependencyInjection\Compiler

Code

private function processDefinition(ContainerBuilder $container, string $id, Definition $definition, array $tagsToKeep) : Definition {
    $instanceofConditionals = $definition->getInstanceofConditionals();
    $autoconfiguredInstanceof = $definition->isAutoconfigured() ? $container->getAutoconfiguredInstanceof() : [];
    if (!$instanceofConditionals && !$autoconfiguredInstanceof) {
        return $definition;
    }
    if (!($class = $container->getParameterBag()
        ->resolveValue($definition->getClass()))) {
        return $definition;
    }
    $conditionals = $this->mergeConditionals($autoconfiguredInstanceof, $instanceofConditionals, $container);
    $definition->setInstanceofConditionals([]);
    $shared = null;
    $instanceofTags = [];
    $instanceofCalls = [];
    $instanceofBindings = [];
    $reflectionClass = null;
    $parent = $definition instanceof ChildDefinition ? $definition->getParent() : null;
    foreach ($conditionals as $interface => $instanceofDefs) {
        if ($interface !== $class && !($reflectionClass ??= $container->getReflectionClass($class, false) ?: false)) {
            continue;
        }
        if ($interface !== $class && !is_subclass_of($class, $interface)) {
            continue;
        }
        foreach ($instanceofDefs as $key => $instanceofDef) {
            
            /** @var ChildDefinition $instanceofDef */
            $instanceofDef = clone $instanceofDef;
            $instanceofDef->setAbstract(true)
                ->setParent($parent ?: '.abstract.instanceof.' . $id);
            $parent = '.instanceof.' . $interface . '.' . $key . '.' . $id;
            $container->setDefinition($parent, $instanceofDef);
            $instanceofTags[] = [
                $interface,
                $instanceofDef->getTags(),
            ];
            $instanceofBindings = $instanceofDef->getBindings() + $instanceofBindings;
            foreach ($instanceofDef->getMethodCalls() as $methodCall) {
                $instanceofCalls[] = $methodCall;
            }
            $instanceofDef->setTags([]);
            $instanceofDef->setMethodCalls([]);
            $instanceofDef->setBindings([]);
            if (isset($instanceofDef->getChanges()['shared'])) {
                $shared = $instanceofDef->isShared();
            }
        }
    }
    if ($parent) {
        $bindings = $definition->getBindings();
        $abstract = $container->setDefinition('.abstract.instanceof.' . $id, $definition);
        $definition->setBindings([]);
        $definition = serialize($definition);
        if (Definition::class === $abstract::class) {
            // cast Definition to ChildDefinition
            $definition = substr_replace($definition, '53', 2, 2);
            $definition = substr_replace($definition, 'Child', 44, 0);
        }
        
        /** @var ChildDefinition $definition */
        $definition = unserialize($definition);
        $definition->setParent($parent);
        if (null !== $shared && !isset($definition->getChanges()['shared'])) {
            $definition->setShared($shared);
        }
        // Don't add tags to service decorators
        $i = \count($instanceofTags);
        while (0 <= --$i) {
            [
                $interface,
                $tags,
            ] = $instanceofTags[$i];
            foreach ($tags as $k => $v) {
                if (null === $definition->getDecoratedService() || $interface === $definition->getClass() || \in_array($k, $tagsToKeep, true)) {
                    foreach ($v as $v) {
                        if ($definition->hasTag($k) && \in_array($v, $definition->getTag($k), true)) {
                            continue;
                        }
                        $definition->addTag($k, $v);
                    }
                }
            }
        }
        $definition->setMethodCalls(array_merge($instanceofCalls, $definition->getMethodCalls()));
        $definition->setBindings($bindings + $instanceofBindings);
        // reset fields with "merge" behavior
        $abstract->setBindings([])
            ->setArguments([])
            ->setMethodCalls([])
            ->setDecoratedService(null)
            ->setTags([])
            ->setAbstract(true);
    }
    return $definition;
}