Merge branch '3.4' into 4.3

* 3.4:
  [FrameworkBundle][Config] Ignore exeptions thrown during reflection classes autoload

Author: nicolas-grekas

Resource/ClassExistenceResource.php

@@ -76,10 +76,14 @@ public function isFresh($timestamp)
 
             try {
                 $exists = class_exists($this->resource) || interface_exists($this->resource, false) || trait_exists($this->resource, false);
-            } catch (\ReflectionException $e) {
-                if (0 >= $timestamp) {
-                    unset(self::$existsCache[1][$this->resource]);
-                    throw $e;
+            } catch (\Exception $e) {
+                try {
+                    self::throwOnRequiredClass($this->resource, $e);
+                } catch (\ReflectionException $e) {
+                    if (0 >= $timestamp) {
+                        unset(self::$existsCache[1][$this->resource]);
+                        throw $e;
+                    }
                 }
             } finally {
                 self::$autoloadedClass = $autoloadedClass;
@@ -109,24 +113,57 @@ public function __sleep(): array
     }
 
     /**
-     * @throws \ReflectionException When $class is not found and is required
+     * Throws a reflection exception when the passed class does not exist but is required.
+     *
+     * A class is considered "not required" when it's loaded as part of a "class_exists" or similar check.
+     *
+     * This function can be used as an autoload function to throw a reflection
+     * exception if the class was not found by previous autoload functions.
+     *
+     * A previous exception can be passed. In this case, the class is considered as being
+     * required totally, so if it doesn't exist, a reflection exception is always thrown.
+     * If it exists, the previous exception is rethrown.
+     *
+     * @throws \ReflectionException
      *
      * @internal
      */
-    public static function throwOnRequiredClass($class)
+    public static function throwOnRequiredClass($class, \Exception $previous = null)
     {
-        if (self::$autoloadedClass === $class) {
+        // If the passed class is the resource being checked, we shouldn't throw.
+        if (null === $previous && self::$autoloadedClass === $class) {
+            return;
+        }
+
+        if (class_exists($class, false) || interface_exists($class, false) || trait_exists($class, false)) {
+            if (null !== $previous) {
+                throw $previous;
+            }
+
             return;
         }
-        $e = new \ReflectionException("Class $class not found");
+
+        if ($previous instanceof \ReflectionException) {
+            throw $previous;
+        }
+
+        $e = new \ReflectionException("Class $class not found", 0, $previous);
+
+        if (null !== $previous) {
+            throw $e;
+        }
+
         $trace = $e->getTrace();
         $autoloadFrame = [
             'function' => 'spl_autoload_call',
             'args' => [$class],
         ];
-        $i = 1 + array_search($autoloadFrame, $trace, true);
 
-        if (isset($trace[$i]['function']) && !isset($trace[$i]['class'])) {
+        if (false === $i = array_search($autoloadFrame, $trace, true)) {
+            throw $e;
+        }
+
+        if (isset($trace[++$i]['function']) && !isset($trace[$i]['class'])) {
             switch ($trace[$i]['function']) {
                 case 'get_class_methods':
                 case 'get_class_vars':