comparison vendor/symfony/dependency-injection/Compiler/ResolveInstanceofConditionalsPass.php @ 17:129ea1e6d783

Update, including to Drupal core 8.6.10

 namespace Symfony\Component\DependencyInjection\Compiler;
 
 use Symfony\Component\DependencyInjection\ChildDefinition;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
 use Symfony\Component\DependencyInjection\Exception\RuntimeException;
-use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
 
 /**
  * Applies instanceof conditionals to definitions.
  *
  * @author Nicolas Grekas <[e-mail]>

     }
 
     private function processDefinition(ContainerBuilder $container, $id, Definition $definition)
     {
         $instanceofConditionals = $definition->getInstanceofConditionals();
-        $autoconfiguredInstanceof = $definition->isAutoconfigured() ? $container->getAutoconfiguredInstanceof() : array();
+        $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(array());
+        $definition->setInstanceofConditionals([]);
         $parent = $shared = null;
-        $instanceofTags = array();
+        $instanceofTags = [];
 
         foreach ($conditionals as $interface => $instanceofDefs) {
             if ($interface !== $class && (!$container->getReflectionClass($class, false))) {
                 continue;
             }

                 $instanceofDef = clone $instanceofDef;
                 $instanceofDef->setAbstract(true)->setParent($parent ?: 'abstract.instanceof.'.$id);
                 $parent = 'instanceof.'.$interface.'.'.$key.'.'.$id;
                 $container->setDefinition($parent, $instanceofDef);
                 $instanceofTags[] = $instanceofDef->getTags();
-                $instanceofDef->setTags(array());
+                $instanceofDef->setTags([]);
 
                 if (isset($instanceofDef->getChanges()['shared'])) {
                     $shared = $instanceofDef->isShared();
                 }
             }

         if ($parent) {
             $bindings = $definition->getBindings();
             $abstract = $container->setDefinition('abstract.instanceof.'.$id, $definition);
 
             // cast Definition to ChildDefinition
-            $definition->setBindings(array());
+            $definition->setBindings([]);
             $definition = serialize($definition);
             $definition = substr_replace($definition, '53', 2, 2);
             $definition = substr_replace($definition, 'Child', 44, 0);
             $definition = unserialize($definition);
             $definition->setParent($parent);
 
             if (null !== $shared && !isset($definition->getChanges()['shared'])) {
                 $definition->setShared($shared);
             }
 
-            $i = count($instanceofTags);
+            $i = \count($instanceofTags);
             while (0 <= --$i) {
                 foreach ($instanceofTags[$i] as $k => $v) {
                     foreach ($v as $v) {
-                        if ($definition->hasTag($k) && in_array($v, $definition->getTag($k))) {
+                        if ($definition->hasTag($k) && \in_array($v, $definition->getTag($k))) {
                             continue;
                         }
                         $definition->addTag($k, $v);
                     }
                 }
             }
 
+            $definition->setBindings($bindings);
+
             // reset fields with "merge" behavior
             $abstract
-                ->setBindings($bindings)
-                ->setArguments(array())
-                ->setMethodCalls(array())
+                ->setBindings([])
+                ->setArguments([])
+                ->setMethodCalls([])
                 ->setDecoratedService(null)
-                ->setTags(array())
+                ->setTags([])
                 ->setAbstract(true);
         }
 
         return $definition;
     }
 
     private function mergeConditionals(array $autoconfiguredInstanceof, array $instanceofConditionals, ContainerBuilder $container)
     {
         // make each value an array of ChildDefinition
-        $conditionals = array_map(function ($childDef) { return array($childDef); }, $autoconfiguredInstanceof);
+        $conditionals = array_map(function ($childDef) { return [$childDef]; }, $autoconfiguredInstanceof);
 
         foreach ($instanceofConditionals as $interface => $instanceofDef) {
             // make sure the interface/class exists (but don't validate automaticInstanceofConditionals)
             if (!$container->getReflectionClass($interface)) {
                 throw new RuntimeException(sprintf('"%s" is set as an "instanceof" conditional, but it does not exist.', $interface));
             }
 
             if (!isset($autoconfiguredInstanceof[$interface])) {
-                $conditionals[$interface] = array();
+                $conditionals[$interface] = [];
             }
 
             $conditionals[$interface][] = $instanceofDef;
         }