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

Update, including to Drupal core 8.6.10

  * @author Kévin Dunglas <[e-mail]>
  * @author Nicolas Grekas <[e-mail]>
  */
 class AutowirePass extends AbstractRecursivePass
 {
-    private $definedTypes = array();
+    private $definedTypes = [];
     private $types;
     private $ambiguousServiceTypes;
-    private $autowired = array();
+    private $autowired = [];
     private $lastFailure;
     private $throwOnAutowiringException;
-    private $autowiringExceptions = array();
+    private $autowiringExceptions = [];
     private $strictMode;
 
     /**
      * @param bool $throwOnAutowireException Errors can be retrieved via Definition::getErrors()
      */

      * {@inheritdoc}
      */
     public function process(ContainerBuilder $container)
     {
         // clear out any possibly stored exceptions from before
-        $this->autowiringExceptions = array();
+        $this->autowiringExceptions = [];
         $this->strictMode = $container->hasParameter('container.autowiring.strict_mode') && $container->getParameter('container.autowiring.strict_mode');
 
         try {
             parent::process($container);
         } finally {
-            $this->definedTypes = array();
+            $this->definedTypes = [];
             $this->types = null;
             $this->ambiguousServiceTypes = null;
-            $this->autowired = array();
+            $this->autowired = [];
         }
     }
 
     /**
      * Creates a resource to help know if this service has changed.

      */
     public static function createResourceForClass(\ReflectionClass $reflectionClass)
     {
         @trigger_error('The '.__METHOD__.'() method is deprecated since Symfony 3.3 and will be removed in 4.0. Use ContainerBuilder::getReflectionClass() instead.', E_USER_DEPRECATED);
 
-        $metadata = array();
+        $metadata = [];
 
         foreach ($reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $reflectionMethod) {
             if (!$reflectionMethod->isStatic()) {
                 $metadata[$reflectionMethod->name] = self::getResourceMetadataForMethod($reflectionMethod);
             }

         } catch (RuntimeException $e) {
             throw new AutowiringFailedException($this->currentId, $e->getMessage(), 0, $e);
         }
 
         if ($constructor) {
-            array_unshift($methodCalls, array($constructor, $value->getArguments()));
+            array_unshift($methodCalls, [$constructor, $value->getArguments()]);
         }
 
         $methodCalls = $this->autowireCalls($reflectionClass, $methodCalls);
 
         if ($constructor) {

     /**
      * Populates the list of available types.
      */
     private function populateAvailableTypes($onlyAutowiringTypes = false)
     {
-        $this->types = array();
+        $this->types = [];
         if (!$onlyAutowiringTypes) {
-            $this->ambiguousServiceTypes = array();
+            $this->ambiguousServiceTypes = [];
         }
 
         foreach ($this->container->getDefinitions() as $id => $definition) {
             $this->populateAvailableType($id, $definition, $onlyAutowiringTypes);
         }

             return;
         }
 
         // keep an array of all services matching this type
         if (!isset($this->ambiguousServiceTypes[$type])) {
-            $this->ambiguousServiceTypes[$type] = array($this->types[$type]);
+            $this->ambiguousServiceTypes[$type] = [$this->types[$type]];
             unset($this->types[$type]);
         }
         $this->ambiguousServiceTypes[$type][] = $id;
     }
 

         return new TypedReference($argumentId, $type);
     }
 
     private function createTypeNotFoundMessage(TypedReference $reference, $label)
     {
-        if (!$r = $this->container->getReflectionClass($type = $reference->getType(), false)) {
+        $trackResources = $this->container->isTrackingResources();
+        $this->container->setResourceTracking(false);
+        try {
+            if ($r = $this->container->getReflectionClass($type = $reference->getType(), false)) {
+                $alternatives = $this->createTypeAlternatives($reference);
+            }
+        } finally {
+            $this->container->setResourceTracking($trackResources);
+        }
+
+        if (!$r) {
             // either $type does not exist or a parent class does not exist
             try {
                 $resource = new ClassExistenceResource($type, false);
                 // isFresh() will explode ONLY if a parent class/trait does not exist
                 $resource->isFresh(0);

                 $parentMsg = $e->getMessage();
             }
 
             $message = sprintf('has type "%s" but this class %s.', $type, $parentMsg ? sprintf('is missing a parent class (%s)', $parentMsg) : 'was not found');
         } else {
-            $alternatives = $this->createTypeAlternatives($reference);
             $message = $this->container->has($type) ? 'this service is abstract' : 'no such service exists';
             $message = sprintf('references %s "%s" but %s.%s', $r->isInterface() ? 'interface' : 'class', $type, $message, $alternatives);
 
             if ($r->isInterface() && !$alternatives) {
                 $message .= ' Did you create a class that implements this interface?';

     /**
      * @deprecated since version 3.3, to be removed in 4.0.
      */
     private static function getResourceMetadataForMethod(\ReflectionMethod $method)
     {
-        $methodArgumentsMetadata = array();
+        $methodArgumentsMetadata = [];
         foreach ($method->getParameters() as $parameter) {
             try {
                 $class = $parameter->getClass();
             } catch (\ReflectionException $e) {
                 // type-hint is against a non-existent class
                 $class = false;
             }
 
             $isVariadic = method_exists($parameter, 'isVariadic') && $parameter->isVariadic();
-            $methodArgumentsMetadata[] = array(
+            $methodArgumentsMetadata[] = [
                 'class' => $class,
                 'isOptional' => $parameter->isOptional(),
                 'defaultValue' => ($parameter->isOptional() && !$isVariadic) ? $parameter->getDefaultValue() : null,
-            );
+            ];
         }
 
         return $methodArgumentsMetadata;
     }
 
     private function getAliasesSuggestionForType($type, $extraContext = null)
     {
-        $aliases = array();
+        $aliases = [];
         foreach (class_parents($type) + class_implements($type) as $parent) {
             if ($this->container->has($parent) && !$this->container->findDefinition($parent)->isAbstract()) {
                 $aliases[] = $parent;
             }
         }
 
         $extraContext = $extraContext ? ' '.$extraContext : '';
-        if (1 < $len = count($aliases)) {
+        if (1 < $len = \count($aliases)) {
             $message = sprintf('Try changing the type-hint%s to one of its parents: ', $extraContext);
             for ($i = 0, --$len; $i < $len; ++$i) {
                 $message .= sprintf('%s "%s", ', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
             }
             $message .= sprintf('or %s "%s".', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);