[Debug][ErrorHandler] fix operator precedence

The ErrorHandler's job includes handling out of memory (OOM) exceptions,
therefore it is imoprtant that that feature works. In the current state,
when handling OOM exceptions, the error handler produces an OOM error
itself, because the old 10k reserve is apparently not enough anymore.
To mitigate that, the reserved memory gets bumped to 32k (which is enouogh).

.gitattributes

@@ -0,0 +1,4 @@
+/Tests export-ignore
+/phpunit.xml.dist export-ignore
+/.gitattributes export-ignore
+/.gitignore export-ignore

BufferingLogger.php

@@ -13,15 +13,22 @@ namespace Symfony\Component\Debug;
 
 use Psr\Log\AbstractLogger;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', BufferingLogger::class, \Symfony\Component\ErrorHandler\BufferingLogger::class), \E_USER_DEPRECATED);
+
 /**
  * A buffering logger that stacks logs for later.
  *
  * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\BufferingLogger instead.
  */
 class BufferingLogger extends AbstractLogger
 {
     private $logs = [];
 
+    /**
+     * @return void
+     */
     public function log($level, $message, array $context = [])
     {
         $this->logs[] = [$level, $message, $context];

CHANGELOG.md

@@ -1,62 +1,75 @@
 CHANGELOG
 =========
 
+4.4.0
+-----
+
+ * deprecated `FlattenException`, use the `FlattenException` of the `ErrorHandler` component
+ * deprecated the whole component in favor of the `ErrorHandler` component
+
+4.3.0
+-----
+
+ * made the `ErrorHandler` and `ExceptionHandler` classes final
+ * added `Exception\FlattenException::getAsString` and
+   `Exception\FlattenException::getTraceAsString` to increase compatibility to php
+   exception objects
+
 4.0.0
 -----
 
-* removed the symfony_debug extension
-* removed `ContextErrorException`
+ * removed the symfony_debug extension
+ * removed `ContextErrorException`
 
 3.4.0
 -----
 
-* deprecated `ErrorHandler::stackErrors()` and `ErrorHandler::unstackErrors()`
+ * deprecated `ErrorHandler::stackErrors()` and `ErrorHandler::unstackErrors()`
 
 3.3.0
 -----
 
-* deprecated the `ContextErrorException` class: use \ErrorException directly now
+ * deprecated the `ContextErrorException` class: use \ErrorException directly now
 
 3.2.0
 -----
 
-* `FlattenException::getTrace()` now returns additional type descriptions
-  `integer` and `float`.
-
+ * `FlattenException::getTrace()` now returns additional type descriptions
+   `integer` and `float`.
 
 3.0.0
 -----
 
-* removed classes, methods and interfaces deprecated in 2.x
+ * removed classes, methods and interfaces deprecated in 2.x
 
 2.8.0
 -----
 
-* added BufferingLogger for errors that happen before a proper logger is configured
-* allow throwing from `__toString()` with `return trigger_error($e, E_USER_ERROR);`
-* deprecate ExceptionHandler::createResponse
+ * added BufferingLogger for errors that happen before a proper logger is configured
+ * allow throwing from `__toString()` with `return trigger_error($e, E_USER_ERROR);`
+ * deprecate ExceptionHandler::createResponse
 
 2.7.0
 -----
 
-* added deprecations checking for parent interfaces/classes to DebugClassLoader
-* added ZTS support to symfony_debug extension
-* added symfony_debug_backtrace() to symfony_debug extension
-  to track the backtrace of fatal errors
+ * added deprecations checking for parent interfaces/classes to DebugClassLoader
+ * added ZTS support to symfony_debug extension
+ * added symfony_debug_backtrace() to symfony_debug extension
+   to track the backtrace of fatal errors
 
 2.6.0
 -----
 
-* generalized ErrorHandler and ExceptionHandler,
-  with some new methods and others deprecated
-* enhanced error messages for uncaught exceptions
+ * generalized ErrorHandler and ExceptionHandler,
+   with some new methods and others deprecated
+ * enhanced error messages for uncaught exceptions
 
 2.5.0
 -----
 
-* added ExceptionHandler::setHandler()
-* added UndefinedMethodFatalErrorHandler
-* deprecated DummyException
+ * added ExceptionHandler::setHandler()
+ * added UndefinedMethodFatalErrorHandler
+ * deprecated DummyException
 
 2.4.0
 -----

Debug.php

@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Debug;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', Debug::class, \Symfony\Component\ErrorHandler\Debug::class), \E_USER_DEPRECATED);
+
 /**
  * Registers all the debug tools.
  *
  * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\Debug instead.
  */
 class Debug
 {
@@ -28,7 +32,7 @@ class Debug
      * @param int  $errorReportingLevel The level of error reporting you want
      * @param bool $displayErrors       Whether to display errors (for development) or just log them (for production)
      */
-    public static function enable($errorReportingLevel = E_ALL, $displayErrors = true)
+    public static function enable($errorReportingLevel = \E_ALL, $displayErrors = true)
     {
         if (static::$enabled) {
             return;
@@ -39,13 +43,13 @@ class Debug
         if (null !== $errorReportingLevel) {
             error_reporting($errorReportingLevel);
         } else {
-            error_reporting(E_ALL);
+            error_reporting(\E_ALL);
         }
 
         if (!\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true)) {
             ini_set('display_errors', 0);
             ExceptionHandler::register();
-        } elseif ($displayErrors && (!filter_var(ini_get('log_errors'), FILTER_VALIDATE_BOOLEAN) || ini_get('error_log'))) {
+        } elseif ($displayErrors && (!filter_var(\ini_get('log_errors'), \FILTER_VALIDATE_BOOLEAN) || \ini_get('error_log'))) {
             // CLI - display errors only if they're not already logged to STDERR
             ini_set('display_errors', 1);
         }

DebugClassLoader.php

@@ -13,6 +13,8 @@ namespace Symfony\Component\Debug;
 
 use PHPUnit\Framework\MockObject\Matcher\StatelessInvocation;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', DebugClassLoader::class, \Symfony\Component\ErrorHandler\DebugClassLoader::class), \E_USER_DEPRECATED);
+
 /**
  * Autoloader checking if the class is really defined in the file found.
  *
@@ -24,6 +26,8 @@ use PHPUnit\Framework\MockObject\Matcher\StatelessInvocation;
  * @author Christophe Coevoet <stof@notk.org>
  * @author Nicolas Grekas <p@tchwork.com>
  * @author Guilhem Niot <guilhem.niot@gmail.com>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\DebugClassLoader instead.
  */
 class DebugClassLoader
 {
@@ -39,6 +43,7 @@ class DebugClassLoader
     private static $internalMethods = [];
     private static $annotatedParameters = [];
     private static $darwinCache = ['/' => ['/', []]];
+    private static $method = [];
 
     public function __construct(callable $classLoader)
     {
@@ -59,7 +64,7 @@ class DebugClassLoader
             } elseif (substr($test, -\strlen($file)) === $file) {
                 // filesystem is case insensitive and realpath() normalizes the case of characters
                 self::$caseCheck = 1;
-            } elseif (false !== stripos(PHP_OS, 'darwin')) {
+            } elseif (false !== stripos(\PHP_OS, 'darwin')) {
                 // on MacOSX, HFS+ is case insensitive but realpath() doesn't normalize the case of characters
                 self::$caseCheck = 2;
             } else {
@@ -85,8 +90,8 @@ class DebugClassLoader
     public static function enable()
     {
         // Ensures we don't hit https://bugs.php.net/42098
-        class_exists('Symfony\Component\Debug\ErrorHandler');
-        class_exists('Psr\Log\LogLevel');
+        class_exists(\Symfony\Component\Debug\ErrorHandler::class);
+        class_exists(\Psr\Log\LogLevel::class);
 
         if (!\is_array($functions = spl_autoload_functions())) {
             return;
@@ -144,7 +149,7 @@ class DebugClassLoader
      */
     public function loadClass($class)
     {
-        $e = error_reporting(error_reporting() | E_PARSE | E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR);
+        $e = error_reporting(error_reporting() | \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR);
 
         try {
             if ($this->isFinder && !isset($this->loaded[$class])) {
@@ -169,7 +174,7 @@ class DebugClassLoader
         $this->checkClass($class, $file);
     }
 
-    private function checkClass($class, $file = null)
+    private function checkClass(string $class, string $file = null)
     {
         $exists = null === $file || class_exists($class, false) || interface_exists($class, false) || trait_exists($class, false);
 
@@ -196,7 +201,7 @@ class DebugClassLoader
             $deprecations = $this->checkAnnotations($refl, $name);
 
             foreach ($deprecations as $message) {
-                @trigger_error($message, E_USER_DEPRECATED);
+                @trigger_error($message, \E_USER_DEPRECATED);
             }
         }
 
@@ -236,10 +241,28 @@ class DebugClassLoader
                     self::${$annotation}[$class] = isset($notice[1]) ? preg_replace('#\.?\r?\n( \*)? *(?= |\r?\n|$)#', '', $notice[1]) : '';
                 }
             }
+
+            if ($refl->isInterface() && false !== strpos($doc, 'method') && preg_match_all('#\n \* @method\s+(static\s+)?+(?:[\w\|&\[\]\\\]+\s+)?(\w+(?:\s*\([^\)]*\))?)+(.+?([[:punct:]]\s*)?)?(?=\r?\n \*(?: @|/$|\r?\n))#', $doc, $notice, \PREG_SET_ORDER)) {
+                foreach ($notice as $method) {
+                    $static = '' !== $method[1];
+                    $name = $method[2];
+                    $description = $method[3] ?? null;
+                    if (false === strpos($name, '(')) {
+                        $name .= '()';
+                    }
+                    if (null !== $description) {
+                        $description = trim($description);
+                        if (!isset($method[4])) {
+                            $description .= '.';
+                        }
+                    }
+                    self::$method[$class][] = [$class, $name, $static, $description];
+                }
+            }
         }
 
         $parent = get_parent_class($class);
-        $parentAndOwnInterfaces = $this->getOwnInterfaces($class, $parent);
+        $parentAndOwnInterfaces = $this->getOwnInterfaces($class, $parent ?: null);
         if ($parent) {
             $parentAndOwnInterfaces[$parent] = $parent;
 
@@ -266,6 +289,28 @@ class DebugClassLoader
             if (isset(self::$internal[$use]) && strncmp($ns, str_replace('_', '\\', $use), $len)) {
                 $deprecations[] = sprintf('The "%s" %s is considered internal%s. It may change without further notice. You should not use it from "%s".', $use, class_exists($use, false) ? 'class' : (interface_exists($use, false) ? 'interface' : 'trait'), self::$internal[$use], $class);
             }
+            if (isset(self::$method[$use])) {
+                if ($refl->isAbstract()) {
+                    if (isset(self::$method[$class])) {
+                        self::$method[$class] = array_merge(self::$method[$class], self::$method[$use]);
+                    } else {
+                        self::$method[$class] = self::$method[$use];
+                    }
+                } elseif (!$refl->isInterface()) {
+                    $hasCall = $refl->hasMethod('__call');
+                    $hasStaticCall = $refl->hasMethod('__callStatic');
+                    foreach (self::$method[$use] as $method) {
+                        [$interface, $name, $static, $description] = $method;
+                        if ($static ? $hasStaticCall : $hasCall) {
+                            continue;
+                        }
+                        $realName = substr($name, 0, strpos($name, '('));
+                        if (!$refl->hasMethod($realName) || !($methodRefl = $refl->getMethod($realName))->isPublic() || ($static && !$methodRefl->isStatic()) || (!$static && $methodRefl->isStatic())) {
+                            $deprecations[] = sprintf('Class "%s" should implement method "%s::%s"%s', $class, ($static ? 'static ' : '').$interface, $name, null == $description ? '.' : ': '.$description);
+                        }
+                    }
+                }
+            }
         }
 
         if (trait_exists($class)) {
@@ -290,12 +335,12 @@ class DebugClassLoader
             }
 
             if ($parent && isset(self::$finalMethods[$parent][$method->name])) {
-                list($declaringClass, $message) = self::$finalMethods[$parent][$method->name];
+                [$declaringClass, $message] = self::$finalMethods[$parent][$method->name];
                 $deprecations[] = sprintf('The "%s::%s()" method is considered final%s. It may change without further notice as of its next major version. You should not extend it from "%s".', $declaringClass, $method->name, $message, $class);
             }
 
             if (isset(self::$internalMethods[$class][$method->name])) {
-                list($declaringClass, $message) = self::$internalMethods[$class][$method->name];
+                [$declaringClass, $message] = self::$internalMethods[$class][$method->name];
                 if (strncmp($ns, $declaringClass, $len)) {
                     $deprecations[] = sprintf('The "%s::%s()" method is considered internal%s. It may change without further notice. You should not extend it from "%s".', $declaringClass, $method->name, $message, $class);
                 }
@@ -311,7 +356,7 @@ class DebugClassLoader
                 }
 
                 foreach (self::$annotatedParameters[$class][$method->name] as $parameterName => $deprecation) {
-                    if (!isset($definedParameters[$parameterName]) && !($doc && preg_match("/\\n\\s+\\* @param (.*?)(?<= )\\\${$parameterName}\\b/", $doc))) {
+                    if (!isset($definedParameters[$parameterName]) && !($doc && preg_match("/\\n\\s+\\* @param +((?(?!callable *\().*?|callable *\(.*\).*?))(?<= )\\\${$parameterName}\\b/", $doc))) {
                         $deprecations[] = sprintf($deprecation, $class);
                     }
                 }
@@ -334,7 +379,7 @@ class DebugClassLoader
             if ($finalOrInternal || $method->isConstructor() || false === strpos($doc, '@param') || StatelessInvocation::class === $class) {
                 continue;
             }
-            if (!preg_match_all('#\n\s+\* @param (.*?)(?<= )\$([a-zA-Z0-9_\x7f-\xff]++)#', $doc, $matches, PREG_SET_ORDER)) {
+            if (!preg_match_all('#\n\s+\* @param +((?(?!callable *\().*?|callable *\(.*\).*?))(?<= )\$([a-zA-Z0-9_\x7f-\xff]++)#', $doc, $matches, \PREG_SET_ORDER)) {
                 continue;
             }
             if (!isset(self::$annotatedParameters[$class][$method->name])) {
@@ -343,10 +388,10 @@ class DebugClassLoader
                     $definedParameters[$parameter->name] = true;
                 }
             }
-            foreach ($matches as list(, $parameterType, $parameterName)) {
+            foreach ($matches as [, $parameterType, $parameterName]) {
                 if (!isset($definedParameters[$parameterName])) {
                     $parameterType = trim($parameterType);
-                    self::$annotatedParameters[$class][$method->name][$parameterName] = sprintf('The "%%s::%s()" method will require a new "%s$%s" argument in the next major version of its parent class "%s", not defining it is deprecated.', $method->name, $parameterType ? $parameterType.' ' : '', $parameterName, $method->class);
+                    self::$annotatedParameters[$class][$method->name][$parameterName] = sprintf('The "%%s::%s()" method will require a new "%s$%s" argument in the next major version of its %s "%s", not defining it is deprecated.', $method->name, $parameterType ? $parameterType.' ' : '', $parameterName, interface_exists($class) ? 'interface' : 'parent class', $method->class);
                 }
             }
         }
@@ -354,6 +399,12 @@ class DebugClassLoader
         return $deprecations;
     }
 
+    /**
+     * @param string $file
+     * @param string $class
+     *
+     * @return array|null
+     */
     public function checkCase(\ReflectionClass $refl, $file, $class)
     {
         $real = explode('\\', $class.strrchr($file, '.'));
@@ -370,7 +421,7 @@ class DebugClassLoader
         array_splice($tail, 0, $i + 1);
 
         if (!$tail) {
-            return;
+            return null;
         }
 
         $tail = \DIRECTORY_SEPARATOR.implode(\DIRECTORY_SEPARATOR, $tail);
@@ -386,12 +437,14 @@ class DebugClassLoader
         ) {
             return [substr($tail, -$tailLen + 1), substr($real, -$tailLen + 1), substr($real, 0, -$tailLen + 1)];
         }
+
+        return null;
     }
 
     /**
      * `realpath` on MacOSX doesn't normalize the case of characters.
      */
-    private function darwinRealpath($real)
+    private function darwinRealpath(string $real): string
     {
         $i = 1 + strrpos($real, '/');
         $file = substr($real, $i);
@@ -406,7 +459,11 @@ class DebugClassLoader
                 $real = self::$darwinCache[$kDir][0];
             } else {
                 $dir = getcwd();
-                chdir($real);
+
+                if (!@chdir($real)) {
+                    return $real.$file;
+                }
+
                 $real = getcwd().'/';
                 chdir($dir);
 
@@ -433,7 +490,7 @@ class DebugClassLoader
         }
 
         if (isset($dirFiles[$file])) {
-            return $real .= $dirFiles[$file];
+            return $real.$dirFiles[$file];
         }
 
         $kFile = strtolower($file);
@@ -452,18 +509,15 @@ class DebugClassLoader
             self::$darwinCache[$kDir][1] = $dirFiles;
         }
 
-        return $real .= $dirFiles[$kFile];
+        return $real.$dirFiles[$kFile];
     }
 
     /**
      * `class_implements` includes interfaces from the parents so we have to manually exclude them.
      *
-     * @param string       $class
-     * @param string|false $parent
-     *
      * @return string[]
      */
-    private function getOwnInterfaces($class, $parent)
+    private function getOwnInterfaces(string $class, ?string $parent): array
     {
         $ownInterfaces = class_implements($class, false);
 

ErrorHandler.php

@@ -23,6 +23,8 @@ use Symfony\Component\Debug\FatalErrorHandler\FatalErrorHandlerInterface;
 use Symfony\Component\Debug\FatalErrorHandler\UndefinedFunctionFatalErrorHandler;
 use Symfony\Component\Debug\FatalErrorHandler\UndefinedMethodFatalErrorHandler;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', ErrorHandler::class, \Symfony\Component\ErrorHandler\ErrorHandler::class), \E_USER_DEPRECATED);
+
 /**
  * A generic ErrorHandler for the PHP engine.
  *
@@ -45,43 +47,47 @@ use Symfony\Component\Debug\FatalErrorHandler\UndefinedMethodFatalErrorHandler;
  *
  * @author Nicolas Grekas <p@tchwork.com>
  * @author Grégoire Pineau <lyrixx@lyrixx.info>
+ *
+ * @final since Symfony 4.3
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\ErrorHandler instead.
  */
 class ErrorHandler
 {
     private $levels = [
-        E_DEPRECATED => 'Deprecated',
-        E_USER_DEPRECATED => 'User Deprecated',
-        E_NOTICE => 'Notice',
-        E_USER_NOTICE => 'User Notice',
-        E_STRICT => 'Runtime Notice',
-        E_WARNING => 'Warning',
-        E_USER_WARNING => 'User Warning',
-        E_COMPILE_WARNING => 'Compile Warning',
-        E_CORE_WARNING => 'Core Warning',
-        E_USER_ERROR => 'User Error',
-        E_RECOVERABLE_ERROR => 'Catchable Fatal Error',
-        E_COMPILE_ERROR => 'Compile Error',
-        E_PARSE => 'Parse Error',
-        E_ERROR => 'Error',
-        E_CORE_ERROR => 'Core Error',
+        \E_DEPRECATED => 'Deprecated',
+        \E_USER_DEPRECATED => 'User Deprecated',
+        \E_NOTICE => 'Notice',
+        \E_USER_NOTICE => 'User Notice',
+        \E_STRICT => 'Runtime Notice',
+        \E_WARNING => 'Warning',
+        \E_USER_WARNING => 'User Warning',
+        \E_COMPILE_WARNING => 'Compile Warning',
+        \E_CORE_WARNING => 'Core Warning',
+        \E_USER_ERROR => 'User Error',
+        \E_RECOVERABLE_ERROR => 'Catchable Fatal Error',
+        \E_COMPILE_ERROR => 'Compile Error',
+        \E_PARSE => 'Parse Error',
+        \E_ERROR => 'Error',
+        \E_CORE_ERROR => 'Core Error',
     ];
 
     private $loggers = [
-        E_DEPRECATED => [null, LogLevel::INFO],
-        E_USER_DEPRECATED => [null, LogLevel::INFO],
-        E_NOTICE => [null, LogLevel::WARNING],
-        E_USER_NOTICE => [null, LogLevel::WARNING],
-        E_STRICT => [null, LogLevel::WARNING],
-        E_WARNING => [null, LogLevel::WARNING],
-        E_USER_WARNING => [null, LogLevel::WARNING],
-        E_COMPILE_WARNING => [null, LogLevel::WARNING],
-        E_CORE_WARNING => [null, LogLevel::WARNING],
-        E_USER_ERROR => [null, LogLevel::CRITICAL],
-        E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],
-        E_COMPILE_ERROR => [null, LogLevel::CRITICAL],
-        E_PARSE => [null, LogLevel::CRITICAL],
-        E_ERROR => [null, LogLevel::CRITICAL],
-        E_CORE_ERROR => [null, LogLevel::CRITICAL],
+        \E_DEPRECATED => [null, LogLevel::INFO],
+        \E_USER_DEPRECATED => [null, LogLevel::INFO],
+        \E_NOTICE => [null, LogLevel::WARNING],
+        \E_USER_NOTICE => [null, LogLevel::WARNING],
+        \E_STRICT => [null, LogLevel::WARNING],
+        \E_WARNING => [null, LogLevel::WARNING],
+        \E_USER_WARNING => [null, LogLevel::WARNING],
+        \E_COMPILE_WARNING => [null, LogLevel::WARNING],
+        \E_CORE_WARNING => [null, LogLevel::WARNING],
+        \E_USER_ERROR => [null, LogLevel::CRITICAL],
+        \E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],
+        \E_COMPILE_ERROR => [null, LogLevel::CRITICAL],
+        \E_PARSE => [null, LogLevel::CRITICAL],
+        \E_ERROR => [null, LogLevel::CRITICAL],
+        \E_CORE_ERROR => [null, LogLevel::CRITICAL],
     ];
 
     private $thrownErrors = 0x1FFF; // E_ALL - E_DEPRECATED - E_USER_DEPRECATED
@@ -113,7 +119,7 @@ class ErrorHandler
     public static function register(self $handler = null, $replace = true)
     {
         if (null === self::$reservedMemory) {
-            self::$reservedMemory = str_repeat('x', 10240);
+            self::$reservedMemory = str_repeat('x', 32768);
             register_shutdown_function(__CLASS__.'::handleFatalError');
         }
 
@@ -152,7 +158,7 @@ class ErrorHandler
             $handler->setExceptionHandler($prev);
         }
 
-        $handler->throwAt(E_ALL & $handler->thrownErrors, true);
+        $handler->throwAt(\E_ALL & $handler->thrownErrors, true);
 
         return $handler;
     }
@@ -163,18 +169,17 @@ class ErrorHandler
             $this->bootstrappingLogger = $bootstrappingLogger;
             $this->setDefaultLogger($bootstrappingLogger);
         }
-        $this->traceReflector = new \ReflectionProperty('Exception', 'trace');
+        $this->traceReflector = new \ReflectionProperty(\Exception::class, 'trace');
         $this->traceReflector->setAccessible(true);
     }
 
     /**
      * Sets a logger to non assigned errors levels.
      *
-     * @param LoggerInterface $logger  A PSR-3 logger to put as default for the given levels
-     * @param array|int       $levels  An array map of E_* to LogLevel::* or an integer bit field of E_* constants
-     * @param bool            $replace Whether to replace or not any existing logger
+     * @param array|int $levels  An array map of E_* to LogLevel::* or an integer bit field of E_* constants
+     * @param bool      $replace Whether to replace or not any existing logger
      */
-    public function setDefaultLogger(LoggerInterface $logger, $levels = E_ALL, $replace = false)
+    public function setDefaultLogger(LoggerInterface $logger, $levels = \E_ALL, $replace = false)
     {
         $loggers = [];
 
@@ -186,7 +191,7 @@ class ErrorHandler
             }
         } else {
             if (null === $levels) {
-                $levels = E_ALL;
+                $levels = \E_ALL;
             }
             foreach ($this->loggers as $type => $log) {
                 if (($type & $levels) && (empty($log[0]) || $replace || $log[0] === $this->bootstrappingLogger)) {
@@ -221,14 +226,14 @@ class ErrorHandler
             if (!\is_array($log)) {
                 $log = [$log];
             } elseif (!\array_key_exists(0, $log)) {
-                throw new \InvalidArgumentException('No logger provided');
+                throw new \InvalidArgumentException('No logger provided.');
             }
             if (null === $log[0]) {
                 $this->loggedErrors &= ~$type;
             } elseif ($log[0] instanceof LoggerInterface) {
                 $this->loggedErrors |= $type;
             } else {
-                throw new \InvalidArgumentException('Invalid logger provided');
+                throw new \InvalidArgumentException('Invalid logger provided.');
             }
             $this->loggers[$type] = $log + $prev[$type];
 
@@ -240,7 +245,7 @@ class ErrorHandler
 
         if ($flush) {
             foreach ($this->bootstrappingLogger->cleanLogs() as $log) {
-                $type = $log[2]['exception'] instanceof \ErrorException ? $log[2]['exception']->getSeverity() : E_ERROR;
+                $type = $log[2]['exception'] instanceof \ErrorException ? $log[2]['exception']->getSeverity() : \E_ERROR;
                 if (!isset($flush[$type])) {
                     $this->bootstrappingLogger->log($log[0], $log[1], $log[2]);
                 } elseif ($this->loggers[$type][0]) {
@@ -278,7 +283,7 @@ class ErrorHandler
     public function throwAt($levels, $replace = false)
     {
         $prev = $this->thrownErrors;
-        $this->thrownErrors = ($levels | E_RECOVERABLE_ERROR | E_USER_ERROR) & ~E_USER_DEPRECATED & ~E_DEPRECATED;
+        $this->thrownErrors = ($levels | \E_RECOVERABLE_ERROR | \E_USER_ERROR) & ~\E_USER_DEPRECATED & ~\E_DEPRECATED;
         if (!$replace) {
             $this->thrownErrors |= $prev;
         }
@@ -347,10 +352,10 @@ class ErrorHandler
     /**
      * Re-registers as a PHP error handler if levels changed.
      */
-    private function reRegister($prev)
+    private function reRegister(int $prev)
     {
-        if ($prev !== $this->thrownErrors | $this->loggedErrors) {
-            $handler = set_error_handler('var_dump');
+        if ($prev !== ($this->thrownErrors | $this->loggedErrors)) {
+            $handler = set_error_handler('is_int');
             $handler = \is_array($handler) ? $handler[0] : null;
             restore_error_handler();
             if ($handler === $this) {
@@ -380,16 +385,15 @@ class ErrorHandler
      */
     public function handleError($type, $message, $file, $line)
     {
-        // @deprecated to be removed in Symfony 5.0
-        if (\PHP_VERSION_ID >= 70300 && $message && '"' === $message[0] && 0 === strpos($message, '"continue') && preg_match('/^"continue(?: \d++)?" targeting switch is equivalent to "break(?: \d++)?"\. Did you mean to use "continue(?: \d++)?"\?$/', $message)) {
-            $type = E_DEPRECATED;
+        if (\PHP_VERSION_ID >= 70300 && \E_WARNING === $type && '"' === $message[0] && false !== strpos($message, '" targeting switch is equivalent to "break')) {
+            $type = \E_DEPRECATED;
         }
 
         // Level is the current error reporting level to manage silent error.
         $level = error_reporting();
         $silenced = 0 === ($level & $type);
         // Strong errors are not authorized to be silenced.
-        $level |= E_RECOVERABLE_ERROR | E_USER_ERROR | E_DEPRECATED | E_USER_DEPRECATED;
+        $level |= \E_RECOVERABLE_ERROR | \E_USER_ERROR | \E_DEPRECATED | \E_USER_DEPRECATED;
         $log = $this->loggedErrors & $type;
         $throw = $this->thrownErrors & $type & $level;
         $type &= $level | $this->screamedErrors;
@@ -399,19 +403,7 @@ class ErrorHandler
         }
         $scope = $this->scopedErrors & $type;
 
-        if (4 < $numArgs = \func_num_args()) {
-            $context = $scope ? (func_get_arg(4) ?: []) : [];
-        } else {
-            $context = [];
-        }
-
-        if (isset($context['GLOBALS']) && $scope) {
-            $e = $context;                  // Whatever the signature of the method,
-            unset($e['GLOBALS'], $context); // $context is always a reference in 5.3
-            $context = $e;
-        }
-
-        if (false !== strpos($message, "class@anonymous\0")) {
+        if (false !== strpos($message, "@anonymous\0")) {
             $logMessage = $this->levels[$type].': '.(new FlattenException())->setMessage($message)->getMessage();
         } else {
             $logMessage = $this->levels[$type].': '.$message;
@@ -422,7 +414,7 @@ class ErrorHandler
             self::$toStringException = null;
         } elseif (!$throw && !($type & $level)) {
             if (!isset(self::$silencedErrorCache[$id = $file.':'.$line])) {
-                $lightTrace = $this->tracedErrors & $type ? $this->cleanTrace(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 5), $type, $file, $line, false) : [];
+                $lightTrace = $this->tracedErrors & $type ? $this->cleanTrace(debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 5), $type, $file, $line, false) : [];
                 $errorAsException = new SilencedErrorContext($type, $file, $line, isset($lightTrace[1]) ? [$lightTrace[0]] : $lightTrace);
             } elseif (isset(self::$silencedErrorCache[$id][$message])) {
                 $lightTrace = null;
@@ -441,7 +433,7 @@ class ErrorHandler
                 self::$silencedErrorCache[$id][$message] = $errorAsException;
             }
             if (null === $lightTrace) {
-                return;
+                return true;
             }
         } else {
             $errorAsException = new \ErrorException($logMessage, 0, $type, $file, $line);
@@ -457,7 +449,7 @@ class ErrorHandler
         }
 
         if ($throw) {
-            if (E_USER_ERROR & $type) {
+            if (\PHP_VERSION_ID < 70400 && \E_USER_ERROR & $type) {
                 for ($i = 1; isset($backtrace[$i]); ++$i) {
                     if (isset($backtrace[$i]['function'], $backtrace[$i]['type'], $backtrace[$i - 1]['function'])
                         && '__toString' === $backtrace[$i]['function']
@@ -472,6 +464,8 @@ class ErrorHandler
                         // `return trigger_error($e, E_USER_ERROR);` allows this error handler
                         // to make $e get through the __toString() barrier.
 
+                        $context = 4 < \func_num_args() ? (func_get_arg(4) ?: []) : [];
+
                         foreach ($context as $e) {
                             if ($e instanceof \Throwable && $e->__toString() === $message) {
                                 self::$toStringException = $e;
@@ -495,8 +489,8 @@ class ErrorHandler
         if ($this->isRecursive) {
             $log = 0;
         } else {
-            if (!\defined('HHVM_VERSION')) {
-                $currentErrorHandler = set_error_handler('var_dump');
+            if (\PHP_VERSION_ID < (\PHP_VERSION_ID < 70400 ? 70316 : 70404)) {
+                $currentErrorHandler = set_error_handler('is_int');
                 restore_error_handler();
             }
 
@@ -507,7 +501,7 @@ class ErrorHandler
             } finally {
                 $this->isRecursive = false;
 
-                if (!\defined('HHVM_VERSION')) {
+                if (\PHP_VERSION_ID < (\PHP_VERSION_ID < 70400 ? 70316 : 70404)) {
                     set_error_handler($currentErrorHandler);
                 }
             }
@@ -532,11 +526,11 @@ class ErrorHandler
         if (!$exception instanceof \Exception) {
             $exception = new FatalThrowableError($exception);
         }
-        $type = $exception instanceof FatalErrorException ? $exception->getSeverity() : E_ERROR;
+        $type = $exception instanceof FatalErrorException ? $exception->getSeverity() : \E_ERROR;
         $handlerException = null;
 
         if (($this->loggedErrors & $type) || $exception instanceof FatalThrowableError) {
-            if (false !== strpos($message = $exception->getMessage(), "class@anonymous\0")) {
+            if (false !== strpos($message = $exception->getMessage(), "@anonymous\0")) {
                 $message = (new FlattenException())->setMessage($message)->getMessage();
             }
             if ($exception instanceof FatalErrorException) {
@@ -574,7 +568,9 @@ class ErrorHandler
         $this->exceptionHandler = null;
         try {
             if (null !== $exceptionHandler) {
-                return $exceptionHandler($exception);
+                $exceptionHandler($exception);
+
+                return;
             }
             $handlerException = $handlerException ?: $exception;
         } catch (\Throwable $handlerException) {
@@ -605,7 +601,7 @@ class ErrorHandler
         $sameHandlerLimit = 10;
 
         while (!\is_array($handler) || !$handler[0] instanceof self) {
-            $handler = set_exception_handler('var_dump');
+            $handler = set_exception_handler('is_int');
             restore_exception_handler();
 
             if (!$handler) {
@@ -637,10 +633,10 @@ class ErrorHandler
             $error = error_get_last();
         }
 
-        if ($error && $error['type'] &= E_PARSE | E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR) {
+        if ($error && $error['type'] &= \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR) {
             // Let's not throw anymore but keep logging
             $handler->throwAt(0, true);
-            $trace = isset($error['backtrace']) ? $error['backtrace'] : null;
+            $trace = $error['backtrace'] ?? null;
 
             if (0 === strpos($error['message'], 'Allowed memory') || 0 === strpos($error['message'], 'Out of memory')) {
                 $exception = new OutOfMemoryException($handler->levels[$error['type']].': '.$error['message'], 0, $error['type'], $error['file'], $error['line'], 2, false, $trace);
@@ -685,7 +681,7 @@ class ErrorHandler
     /**
      * Cleans the trace by removing function arguments and the frames added by the error handler and DebugClassLoader.
      */
-    private function cleanTrace($backtrace, $type, $file, $line, $throw)
+    private function cleanTrace(array $backtrace, int $type, string $file, int $line, bool $throw): array
     {
         $lightTrace = $backtrace;
 

Exception/ClassNotFoundException.php

@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Debug\Exception;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', ClassNotFoundException::class, \Symfony\Component\ErrorHandler\Error\ClassNotFoundError::class), \E_USER_DEPRECATED);
+
 /**
  * Class (or Trait or Interface) Not Found Exception.
  *
  * @author Konstanton Myakshin <koc-dp@yandex.ru>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\Error\ClassNotFoundError instead.
  */
 class ClassNotFoundException extends FatalErrorException
 {

Exception/FatalErrorException.php

@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Debug\Exception;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', FatalErrorException::class, \Symfony\Component\ErrorHandler\Error\FatalError::class), \E_USER_DEPRECATED);
+
 /**
  * Fatal Error Exception.
  *
  * @author Konstanton Myakshin <koc-dp@yandex.ru>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\Error\FatalError instead.
  */
 class FatalErrorException extends \ErrorException
 {
@@ -31,8 +35,7 @@ class FatalErrorException extends \ErrorException
 
             $this->setTrace($trace);
         } elseif (null !== $traceOffset) {
-            if (\function_exists('xdebug_get_function_stack')) {
-                $trace = xdebug_get_function_stack();
+            if (\function_exists('xdebug_get_function_stack') && $trace = @xdebug_get_function_stack()) {
                 if (0 < $traceOffset) {
                     array_splice($trace, -$traceOffset);
                 }
@@ -70,7 +73,7 @@ class FatalErrorException extends \ErrorException
 
     protected function setTrace($trace)
     {
-        $traceReflector = new \ReflectionProperty('Exception', 'trace');
+        $traceReflector = new \ReflectionProperty(\Exception::class, 'trace');
         $traceReflector->setAccessible(true);
         $traceReflector->setValue($this, $trace);
     }

Exception/FatalThrowableError.php

@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Debug\Exception;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4.', FatalThrowableError::class), \E_USER_DEPRECATED);
+
 /**
  * Fatal Throwable Error.
  *
  * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @deprecated since Symfony 4.4
  */
 class FatalThrowableError extends FatalErrorException
 {
@@ -25,11 +29,11 @@ class FatalThrowableError extends FatalErrorException
         $this->originalClassName = \get_class($e);
 
         if ($e instanceof \ParseError) {
-            $severity = E_PARSE;
+            $severity = \E_PARSE;
         } elseif ($e instanceof \TypeError) {
-            $severity = E_RECOVERABLE_ERROR;
+            $severity = \E_RECOVERABLE_ERROR;
         } else {
-            $severity = E_ERROR;
+            $severity = \E_ERROR;
         }
 
         \ErrorException::__construct(

Exception/FlattenException.php

@@ -20,6 +20,8 @@ use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  * Basically, this class removes all objects from the trace.
  *
  * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\Exception\FlattenException instead.
  */
 class FlattenException
 {
@@ -27,18 +29,25 @@ class FlattenException
     private $code;
     private $previous;
     private $trace;
+    private $traceAsString;
     private $class;
     private $statusCode;
     private $headers;
     private $file;
     private $line;
 
+    /**
+     * @return static
+     */
     public static function create(\Exception $exception, $statusCode = null, array $headers = [])
     {
         return static::createFromThrowable($exception, $statusCode, $headers);
     }
 
-    public static function createFromThrowable(\Throwable $exception, ?int $statusCode = null, array $headers = []): self
+    /**
+     * @return static
+     */
+    public static function createFromThrowable(\Throwable $exception, int $statusCode = null, array $headers = [])
     {
         $e = new static();
         $e->setMessage($exception->getMessage());
@@ -125,7 +134,7 @@ class FlattenException
      */
     public function setClass($class)
     {
-        $this->class = 'c' === $class[0] && 0 === strpos($class, "class@anonymous\0") ? get_parent_class($class).'@anonymous' : $class;
+        $this->class = false !== strpos($class, "@anonymous\0") ? (get_parent_class($class) ?: key(class_implements($class)) ?: 'class').'@anonymous' : $class;
 
         return $this;
     }
@@ -170,9 +179,9 @@ class FlattenException
      */
     public function setMessage($message)
     {
-        if (false !== strpos($message, "class@anonymous\0")) {
-            $message = preg_replace_callback('/class@anonymous\x00.*?\.php0x?[0-9a-fA-F]++/', function ($m) {
-                return class_exists($m[0], false) ? get_parent_class($m[0]).'@anonymous' : $m[0];
+        if (false !== strpos($message, "@anonymous\0")) {
+            $message = preg_replace_callback('/[a-zA-Z_\x7f-\xff][\\\\a-zA-Z0-9_\x7f-\xff]*+@anonymous\x00.*?\.php(?:0x?|:[0-9]++\$)[0-9a-fA-F]++/', function ($m) {
+                return class_exists($m[0], false) ? (get_parent_class($m[0]) ?: key(class_implements($m[0])) ?: 'class').'@anonymous' : $m[0];
             }, $message);
         }
 
@@ -232,13 +241,15 @@ class FlattenException
      */
     public function setTraceFromException(\Exception $exception)
     {
-        @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.1, use "setTraceFromThrowable()" instead.', __METHOD__), E_USER_DEPRECATED);
+        @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.1, use "setTraceFromThrowable()" instead.', __METHOD__), \E_USER_DEPRECATED);
 
         $this->setTraceFromThrowable($exception);
     }
 
     public function setTraceFromThrowable(\Throwable $throwable)
     {
+        $this->traceAsString = $throwable->getTraceAsString();
+
         return $this->setTrace($throwable->getTrace(), $throwable->getFile(), $throwable->getLine());
     }
 
@@ -270,11 +281,11 @@ class FlattenException
             $this->trace[] = [
                 'namespace' => $namespace,
                 'short_class' => $class,
-                'class' => isset($entry['class']) ? $entry['class'] : '',
-                'type' => isset($entry['type']) ? $entry['type'] : '',
-                'function' => isset($entry['function']) ? $entry['function'] : null,
-                'file' => isset($entry['file']) ? $entry['file'] : null,
-                'line' => isset($entry['line']) ? $entry['line'] : null,
+                'class' => $entry['class'] ?? '',
+                'type' => $entry['type'] ?? '',
+                'function' => $entry['function'] ?? null,
+                'file' => $entry['file'] ?? null,
+                'line' => $entry['line'] ?? null,
                 'args' => isset($entry['args']) ? $this->flattenArgs($entry['args']) : [],
             ];
         }
@@ -282,7 +293,7 @@ class FlattenException
         return $this;
     }
 
-    private function flattenArgs($args, $level = 0, &$count = 0)
+    private function flattenArgs(array $args, int $level = 0, int &$count = 0): array
     {
         $result = [];
         foreach ($args as $key => $value) {
@@ -318,10 +329,39 @@ class FlattenException
         return $result;
     }
 
-    private function getClassNameFromIncomplete(\__PHP_Incomplete_Class $value)
+    private function getClassNameFromIncomplete(\__PHP_Incomplete_Class $value): string
     {
         $array = new \ArrayObject($value);
 
         return $array['__PHP_Incomplete_Class_Name'];
     }
+
+    public function getTraceAsString()
+    {
+        return $this->traceAsString;
+    }
+
+    public function getAsString()
+    {
+        $message = '';
+        $next = false;
+
+        foreach (array_reverse(array_merge([$this], $this->getAllPrevious())) as $exception) {
+            if ($next) {
+                $message .= 'Next ';
+            } else {
+                $next = true;
+            }
+            $message .= $exception->getClass();
+
+            if ('' != $exception->getMessage()) {
+                $message .= ': '.$exception->getMessage();
+            }
+
+            $message .= ' in '.$exception->getFile().':'.$exception->getLine().
+                "\nStack trace:\n".$exception->getTraceAsString()."\n\n";
+        }
+
+        return rtrim($message);
+    }
 }

Exception/OutOfMemoryException.php

@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Debug\Exception;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', OutOfMemoryException::class, \Symfony\Component\ErrorHandler\Error\OutOfMemoryError::class), \E_USER_DEPRECATED);
+
 /**
  * Out of memory exception.
  *
  * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\Error\OutOfMemoryError instead.
  */
 class OutOfMemoryException extends FatalErrorException
 {

Exception/SilencedErrorContext.php

@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Debug\Exception;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', SilencedErrorContext::class, \Symfony\Component\ErrorHandler\Exception\SilencedErrorContext::class), \E_USER_DEPRECATED);
+
 /**
  * Data Object that represents a Silenced Error.
  *
  * @author Grégoire Pineau <lyrixx@lyrixx.info>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\Exception\SilencedErrorContext instead.
  */
 class SilencedErrorContext implements \JsonSerializable
 {
@@ -54,7 +58,7 @@ class SilencedErrorContext implements \JsonSerializable
         return $this->trace;
     }
 
-    public function JsonSerialize()
+    public function jsonSerialize()
     {
         return [
             'severity' => $this->severity,

Exception/UndefinedFunctionException.php

@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Debug\Exception;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', UndefinedFunctionException::class, \Symfony\Component\ErrorHandler\Error\UndefinedFunctionError::class), \E_USER_DEPRECATED);
+
 /**
  * Undefined Function Exception.
  *
  * @author Konstanton Myakshin <koc-dp@yandex.ru>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\Error\UndefinedFunctionError instead.
  */
 class UndefinedFunctionException extends FatalErrorException
 {

Exception/UndefinedMethodException.php

@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Debug\Exception;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', UndefinedMethodException::class, \Symfony\Component\ErrorHandler\Error\UndefinedMethodError::class), \E_USER_DEPRECATED);
+
 /**
  * Undefined Method Exception.
  *
  * @author Grégoire Pineau <lyrixx@lyrixx.info>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\Error\UndefinedMethodError instead.
  */
 class UndefinedMethodException extends FatalErrorException
 {

FatalErrorHandler/ClassNotFoundFatalErrorHandler.php

@@ -17,10 +17,14 @@ use Symfony\Component\Debug\DebugClassLoader;
 use Symfony\Component\Debug\Exception\ClassNotFoundException;
 use Symfony\Component\Debug\Exception\FatalErrorException;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', ClassNotFoundFatalErrorHandler::class, \Symfony\Component\ErrorHandler\FatalErrorHandler\ClassNotFoundFatalErrorHandler::class), \E_USER_DEPRECATED);
+
 /**
  * ErrorHandler for classes that do not exist.
  *
  * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\FatalErrorHandler\ClassNotFoundFatalErrorHandler instead.
  */
 class ClassNotFoundFatalErrorHandler implements FatalErrorHandlerInterface
 {
@@ -29,48 +33,34 @@ class ClassNotFoundFatalErrorHandler implements FatalErrorHandlerInterface
      */
     public function handleError(array $error, FatalErrorException $exception)
     {
-        $messageLen = \strlen($error['message']);
-        $notFoundSuffix = '\' not found';
-        $notFoundSuffixLen = \strlen($notFoundSuffix);
-        if ($notFoundSuffixLen > $messageLen) {
-            return;
+        if (!preg_match('/^(Class|Interface|Trait) [\'"]([^\'"]+)[\'"] not found$/', $error['message'], $matches)) {
+            return null;
+        }
+        $typeName = strtolower($matches[1]);
+        $fullyQualifiedClassName = $matches[2];
+
+        if (false !== $namespaceSeparatorIndex = strrpos($fullyQualifiedClassName, '\\')) {
+            $className = substr($fullyQualifiedClassName, $namespaceSeparatorIndex + 1);
+            $namespacePrefix = substr($fullyQualifiedClassName, 0, $namespaceSeparatorIndex);
+            $message = sprintf('Attempted to load %s "%s" from namespace "%s".', $typeName, $className, $namespacePrefix);
+            $tail = ' for another namespace?';
+        } else {
+            $className = $fullyQualifiedClassName;
+            $message = sprintf('Attempted to load %s "%s" from the global namespace.', $typeName, $className);
+            $tail = '?';
         }
 
-        if (0 !== substr_compare($error['message'], $notFoundSuffix, -$notFoundSuffixLen)) {
-            return;
-        }
-
-        foreach (['class', 'interface', 'trait'] as $typeName) {
-            $prefix = ucfirst($typeName).' \'';
-            $prefixLen = \strlen($prefix);
-            if (0 !== strpos($error['message'], $prefix)) {
-                continue;
-            }
-
-            $fullyQualifiedClassName = substr($error['message'], $prefixLen, -$notFoundSuffixLen);
-            if (false !== $namespaceSeparatorIndex = strrpos($fullyQualifiedClassName, '\\')) {
-                $className = substr($fullyQualifiedClassName, $namespaceSeparatorIndex + 1);
-                $namespacePrefix = substr($fullyQualifiedClassName, 0, $namespaceSeparatorIndex);
-                $message = sprintf('Attempted to load %s "%s" from namespace "%s".', $typeName, $className, $namespacePrefix);
-                $tail = ' for another namespace?';
+        if ($candidates = $this->getClassCandidates($className)) {
+            $tail = array_pop($candidates).'"?';
+            if ($candidates) {
+                $tail = ' for e.g. "'.implode('", "', $candidates).'" or "'.$tail;
             } else {
-                $className = $fullyQualifiedClassName;
-                $message = sprintf('Attempted to load %s "%s" from the global namespace.', $typeName, $className);
-                $tail = '?';
+                $tail = ' for "'.$tail;
             }
-
-            if ($candidates = $this->getClassCandidates($className)) {
-                $tail = array_pop($candidates).'"?';
-                if ($candidates) {
-                    $tail = ' for e.g. "'.implode('", "', $candidates).'" or "'.$tail;
-                } else {
-                    $tail = ' for "'.$tail;
-                }
-            }
-            $message .= "\nDid you forget a \"use\" statement".$tail;
-
-            return new ClassNotFoundException($message, $exception);
         }
+        $message .= "\nDid you forget a \"use\" statement".$tail;
+
+        return new ClassNotFoundException($message, $exception);
     }
 
     /**

FatalErrorHandler/FatalErrorHandlerInterface.php

@@ -13,18 +13,21 @@ namespace Symfony\Component\Debug\FatalErrorHandler;
 
 use Symfony\Component\Debug\Exception\FatalErrorException;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', FatalErrorHandlerInterface::class, \Symfony\Component\ErrorHandler\FatalErrorHandler\FatalErrorHandlerInterface::class), \E_USER_DEPRECATED);
+
 /**
  * Attempts to convert fatal errors to exceptions.
  *
  * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\FatalErrorHandler\FatalErrorHandlerInterface instead.
  */
 interface FatalErrorHandlerInterface
 {
     /**
      * Attempts to convert an error into an exception.
      *
-     * @param array               $error     An array as returned by error_get_last()
-     * @param FatalErrorException $exception A FatalErrorException instance
+     * @param array $error An array as returned by error_get_last()
      *
      * @return FatalErrorException|null A FatalErrorException instance if the class is able to convert the error, null otherwise
      */

FatalErrorHandler/UndefinedFunctionFatalErrorHandler.php

@@ -14,10 +14,14 @@ namespace Symfony\Component\Debug\FatalErrorHandler;
 use Symfony\Component\Debug\Exception\FatalErrorException;
 use Symfony\Component\Debug\Exception\UndefinedFunctionException;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', UndefinedFunctionFatalErrorHandler::class, \Symfony\Component\ErrorHandler\ErrorEnhancer\UndefinedFunctionErrorEnhancer::class), \E_USER_DEPRECATED);
+
 /**
  * ErrorHandler for undefined functions.
  *
  * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\ErrorEnhancer\UndefinedFunctionErrorEnhancer instead.
  */
 class UndefinedFunctionFatalErrorHandler implements FatalErrorHandlerInterface
 {
@@ -30,17 +34,17 @@ class UndefinedFunctionFatalErrorHandler implements FatalErrorHandlerInterface
         $notFoundSuffix = '()';
         $notFoundSuffixLen = \strlen($notFoundSuffix);
         if ($notFoundSuffixLen > $messageLen) {
-            return;
+            return null;
         }
 
         if (0 !== substr_compare($error['message'], $notFoundSuffix, -$notFoundSuffixLen)) {
-            return;
+            return null;
         }
 
         $prefix = 'Call to undefined function ';
         $prefixLen = \strlen($prefix);
         if (0 !== strpos($error['message'], $prefix)) {
-            return;
+            return null;
         }
 
         $fullyQualifiedFunctionName = substr($error['message'], $prefixLen, -$notFoundSuffixLen);

FatalErrorHandler/UndefinedMethodFatalErrorHandler.php

@@ -14,10 +14,14 @@ namespace Symfony\Component\Debug\FatalErrorHandler;
 use Symfony\Component\Debug\Exception\FatalErrorException;
 use Symfony\Component\Debug\Exception\UndefinedMethodException;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4, use "%s" instead.', UndefinedMethodFatalErrorHandler::class, \Symfony\Component\ErrorHandler\ErrorEnhancer\UndefinedMethodErrorEnhancer::class), \E_USER_DEPRECATED);
+
 /**
  * ErrorHandler for undefined methods.
  *
  * @author Grégoire Pineau <lyrixx@lyrixx.info>
+ *
+ * @deprecated since Symfony 4.4, use Symfony\Component\ErrorHandler\ErrorEnhancer\UndefinedMethodErrorEnhancer instead.
  */
 class UndefinedMethodFatalErrorHandler implements FatalErrorHandlerInterface
 {
@@ -28,7 +32,7 @@ class UndefinedMethodFatalErrorHandler implements FatalErrorHandlerInterface
     {
         preg_match('/^Call to undefined method (.*)::(.*)\(\)$/', $error['message'], $matches);
         if (!$matches) {
-            return;
+            return null;
         }
 
         $className = $matches[1];
@@ -36,7 +40,7 @@ class UndefinedMethodFatalErrorHandler implements FatalErrorHandlerInterface
 
         $message = sprintf('Attempted to call an undefined method named "%s" of class "%s".', $methodName, $className);
 
-        if (!class_exists($className) || null === $methods = get_class_methods($className)) {
+        if ('' === $methodName || !class_exists($className) || null === $methods = get_class_methods($className)) {
             // failed to get the class or its methods on which an unknown method was called (for example on an anonymous class)
             return new UndefinedMethodException($message, $exception);
         }

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2019 Fabien Potencier
+Copyright (c) 2004-2022 Fabien Potencier
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,13 +1,30 @@
 Debug Component
 ===============
 
+**CAUTION**: this component is deprecated since Symfony 4.4. Instead, use the
+[ErrorHandler component](https://github.com/symfony/symfony/tree/master/src/Symfony/Component/ErrorHandler).
+
+-----
+
 The Debug component provides tools to ease debugging PHP code.
 
+Getting Started
+---------------
+
+```
+$ composer require symfony/debug
+```
+
+```php
+use Symfony\Component\Debug\Debug;
+
+Debug::enable();
+```
+
 Resources
 ---------
 
-  * [Documentation](https://symfony.com/doc/current/components/debug/index.html)
-  * [Contributing](https://symfony.com/doc/current/contributing/index.html)
-  * [Report issues](https://github.com/symfony/symfony/issues) and
-    [send Pull Requests](https://github.com/symfony/symfony/pulls)
-    in the [main Symfony repository](https://github.com/symfony/symfony)
+ * [Contributing](https://symfony.com/doc/current/contributing/index.html)
+ * [Report issues](https://github.com/symfony/symfony/issues) and
+   [send Pull Requests](https://github.com/symfony/symfony/pulls)
+   in the [main Symfony repository](https://github.com/symfony/symfony)

Tests/DebugClassLoaderTest.php

@@ -12,8 +12,12 @@
 namespace Symfony\Component\Debug\Tests;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Bridge\Debug\Tests\Fixtures\ExtendsDeprecatedParent;
 use Symfony\Component\Debug\DebugClassLoader;
 
+/**
+ * @group legacy
+ */
 class DebugClassLoaderTest extends TestCase
 {
     /**
@@ -23,24 +27,26 @@ class DebugClassLoaderTest extends TestCase
 
     private $loader;
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->errorReporting = error_reporting(E_ALL);
-        $this->loader = new ClassLoader();
-        spl_autoload_register([$this->loader, 'loadClass'], true, true);
-        DebugClassLoader::enable();
+        $this->loader = [new DebugClassLoader([new ClassLoader(), 'loadClass']), 'loadClass'];
+        spl_autoload_register($this->loader, true, true);
     }
 
-    protected function tearDown()
+    protected function tearDown(): void
     {
-        DebugClassLoader::disable();
-        spl_autoload_unregister([$this->loader, 'loadClass']);
+        spl_autoload_unregister($this->loader);
         error_reporting($this->errorReporting);
     }
 
+    /**
+     * @runInSeparateProcess
+     */
     public function testIdempotence()
     {
         DebugClassLoader::enable();
+        DebugClassLoader::enable();
 
         $functions = spl_autoload_functions();
         foreach ($functions as $function) {
@@ -49,7 +55,7 @@ class DebugClassLoaderTest extends TestCase
                 $reflProp = $reflClass->getProperty('classLoader');
                 $reflProp->setAccessible(true);
 
-                $this->assertNotInstanceOf('Symfony\Component\Debug\DebugClassLoader', $reflProp->getValue($function[0]));
+                $this->assertNotInstanceOf(DebugClassLoader::class, $reflProp->getValue($function[0]));
 
                 return;
             }
@@ -58,49 +64,43 @@ class DebugClassLoaderTest extends TestCase
         $this->fail('DebugClassLoader did not register');
     }
 
-    /**
-     * @expectedException \Exception
-     * @expectedExceptionMessage boo
-     */
     public function testThrowingClass()
     {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('boo');
         try {
-            class_exists(__NAMESPACE__.'\Fixtures\Throwing');
+            class_exists(Fixtures\Throwing::class);
             $this->fail('Exception expected');
         } catch (\Exception $e) {
             $this->assertSame('boo', $e->getMessage());
         }
 
         // the second call also should throw
-        class_exists(__NAMESPACE__.'\Fixtures\Throwing');
+        class_exists(Fixtures\Throwing::class);
     }
 
-    /**
-     * @expectedException \RuntimeException
-     */
     public function testNameCaseMismatch()
     {
-        class_exists(__NAMESPACE__.'\TestingCaseMismatch', true);
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('Case mismatch between loaded and declared class names');
+        class_exists(TestingCaseMismatch::class, true);
     }
 
-    /**
-     * @expectedException \RuntimeException
-     * @expectedExceptionMessage Case mismatch between class and real file names
-     */
     public function testFileCaseMismatch()
     {
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('Case mismatch between class and real file names');
         if (!file_exists(__DIR__.'/Fixtures/CaseMismatch.php')) {
             $this->markTestSkipped('Can only be run on case insensitive filesystems');
         }
 
-        class_exists(__NAMESPACE__.'\Fixtures\CaseMismatch', true);
+        class_exists(Fixtures\CaseMismatch::class, true);
     }
 
-    /**
-     * @expectedException \RuntimeException
-     */
     public function testPsr4CaseMismatch()
     {
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('Case mismatch between loaded and declared class names');
         class_exists(__NAMESPACE__.'\Fixtures\Psr4CaseMismatch', true);
     }
 
@@ -116,7 +116,7 @@ class DebugClassLoaderTest extends TestCase
 
     public function testClassAlias()
     {
-        $this->assertTrue(class_exists(__NAMESPACE__.'\Fixtures\ClassAlias', true));
+        $this->assertTrue(class_exists(Fixtures\ClassAlias::class, true));
     }
 
     /**
@@ -158,7 +158,7 @@ class DebugClassLoaderTest extends TestCase
         $e = error_reporting(0);
         trigger_error('', E_USER_NOTICE);
 
-        class_exists('Test\\'.__NAMESPACE__.'\\NonDeprecatedInterfaceClass', true);
+        class_exists('Test\\'.NonDeprecatedInterfaceClass::class, true);
 
         error_reporting($e);
         restore_error_handler();
@@ -180,7 +180,7 @@ class DebugClassLoaderTest extends TestCase
         $e = error_reporting(0);
         trigger_error('', E_USER_NOTICE);
 
-        class_exists('Symfony\Bridge\Debug\Tests\Fixtures\ExtendsDeprecatedParent', true);
+        class_exists(ExtendsDeprecatedParent::class, true);
 
         error_reporting($e);
         restore_error_handler();
@@ -205,7 +205,7 @@ class DebugClassLoaderTest extends TestCase
         require __DIR__.'/Fixtures/FinalClasses.php';
 
         $i = 1;
-        while (class_exists($finalClass = __NAMESPACE__.'\\Fixtures\\FinalClass'.$i++, false)) {
+        while (class_exists($finalClass = Fixtures\FinalClass::class.$i++, false)) {
             spl_autoload_call($finalClass);
             class_exists('Test\\'.__NAMESPACE__.'\\Extends'.substr($finalClass, strrpos($finalClass, '\\') + 1), true);
         }
@@ -231,7 +231,7 @@ class DebugClassLoaderTest extends TestCase
         set_error_handler(function ($type, $msg) use (&$deprecations) { $deprecations[] = $msg; });
         $e = error_reporting(E_USER_DEPRECATED);
 
-        class_exists(__NAMESPACE__.'\\Fixtures\\ExtendedFinalMethod', true);
+        class_exists(Fixtures\ExtendedFinalMethod::class, true);
 
         error_reporting($e);
         restore_error_handler();
@@ -250,7 +250,7 @@ class DebugClassLoaderTest extends TestCase
         $e = error_reporting(0);
         trigger_error('', E_USER_NOTICE);
 
-        class_exists('Test\\'.__NAMESPACE__.'\\ExtendsAnnotatedClass', true);
+        class_exists('Test\\'.ExtendsAnnotatedClass::class, true);
 
         error_reporting($e);
         restore_error_handler();
@@ -267,7 +267,7 @@ class DebugClassLoaderTest extends TestCase
         set_error_handler(function ($type, $msg) use (&$deprecations) { $deprecations[] = $msg; });
         $e = error_reporting(E_USER_DEPRECATED);
 
-        class_exists('Test\\'.__NAMESPACE__.'\\ExtendsInternals', true);
+        class_exists('Test\\'.ExtendsInternals::class, true);
 
         error_reporting($e);
         restore_error_handler();
@@ -286,14 +286,19 @@ class DebugClassLoaderTest extends TestCase
         set_error_handler(function ($type, $msg) use (&$deprecations) { $deprecations[] = $msg; });
         $e = error_reporting(E_USER_DEPRECATED);
 
-        class_exists(__NAMESPACE__.'\\Fixtures\SubClassWithAnnotatedParameters', true);
+        class_exists(Fixtures\SubClassWithAnnotatedParameters::class, true);
 
         error_reporting($e);
         restore_error_handler();
 
         $this->assertSame([
             'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::quzMethod()" method will require a new "Quz $quz" argument in the next major version of its parent class "Symfony\Component\Debug\Tests\Fixtures\ClassWithAnnotatedParameters", not defining it is deprecated.',
-            'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::whereAmI()" method will require a new "bool $matrix" argument in the next major version of its parent class "Symfony\Component\Debug\Tests\Fixtures\InterfaceWithAnnotatedParameters", not defining it is deprecated.',
+            'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::whereAmI()" method will require a new "bool $matrix" argument in the next major version of its interface "Symfony\Component\Debug\Tests\Fixtures\InterfaceWithAnnotatedParameters", not defining it is deprecated.',
+            'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::iAmHere()" method will require a new "$noType" argument in the next major version of its interface "Symfony\Component\Debug\Tests\Fixtures\InterfaceWithAnnotatedParameters", not defining it is deprecated.',
+            'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::iAmHere()" method will require a new "callable(\Throwable|null $reason, mixed $value) $callback" argument in the next major version of its interface "Symfony\Component\Debug\Tests\Fixtures\InterfaceWithAnnotatedParameters", not defining it is deprecated.',
+            'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::iAmHere()" method will require a new "string $param" argument in the next major version of its interface "Symfony\Component\Debug\Tests\Fixtures\InterfaceWithAnnotatedParameters", not defining it is deprecated.',
+            'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::iAmHere()" method will require a new "callable  ($a,  $b) $anotherOne" argument in the next major version of its interface "Symfony\Component\Debug\Tests\Fixtures\InterfaceWithAnnotatedParameters", not defining it is deprecated.',
+            'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::iAmHere()" method will require a new "Type$WithDollarIsStillAType $ccc" argument in the next major version of its interface "Symfony\Component\Debug\Tests\Fixtures\InterfaceWithAnnotatedParameters", not defining it is deprecated.',
             'The "Symfony\Component\Debug\Tests\Fixtures\SubClassWithAnnotatedParameters::isSymfony()" method will require a new "true $yes" argument in the next major version of its parent class "Symfony\Component\Debug\Tests\Fixtures\ClassWithAnnotatedParameters", not defining it is deprecated.',
         ], $deprecations);
     }
@@ -304,7 +309,47 @@ class DebugClassLoaderTest extends TestCase
         set_error_handler(function ($type, $msg) use (&$deprecations) { $deprecations[] = $msg; });
         $e = error_reporting(E_USER_DEPRECATED);
 
-        class_exists('Test\\'.__NAMESPACE__.'\\UseTraitWithInternalMethod', true);
+        class_exists('Test\\'.UseTraitWithInternalMethod::class, true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $this->assertSame([], $deprecations);
+    }
+
+    public function testVirtualUse()
+    {
+        $deprecations = [];
+        set_error_handler(function ($type, $msg) use (&$deprecations) { $deprecations[] = $msg; });
+        $e = error_reporting(E_USER_DEPRECATED);
+
+        class_exists('Test\\'.ExtendsVirtual::class, true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $this->assertSame([
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::sameLineInterfaceMethodNoBraces()".',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::newLineInterfaceMethod()": Some description!',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::newLineInterfaceMethodNoBraces()": Description.',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::invalidInterfaceMethod()".',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::invalidInterfaceMethodNoBraces()".',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::complexInterfaceMethod($arg, ...$args)".',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::complexInterfaceMethodTyped($arg, int ...$args)": Description ...',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "static Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::staticMethodNoBraces()".',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "static Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::staticMethodTyped(int $arg)": Description.',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtualParent" should implement method "static Symfony\Component\Debug\Tests\Fixtures\VirtualInterface::staticMethodTypedNoBraces()".',
+            'Class "Test\Symfony\Component\Debug\Tests\ExtendsVirtual" should implement method "Symfony\Component\Debug\Tests\Fixtures\VirtualSubInterface::subInterfaceMethod()".',
+        ], $deprecations);
+    }
+
+    public function testVirtualUseWithMagicCall()
+    {
+        $deprecations = [];
+        set_error_handler(function ($type, $msg) use (&$deprecations) { $deprecations[] = $msg; });
+        $e = error_reporting(E_USER_DEPRECATED);
+
+        class_exists('Test\\'.ExtendsVirtualMagicCall::class, true);
 
         error_reporting($e);
         restore_error_handler();
@@ -314,7 +359,7 @@ class DebugClassLoaderTest extends TestCase
 
     public function testEvaluatedCode()
     {
-        $this->assertTrue(class_exists(__NAMESPACE__.'\Fixtures\DefinitionInEvaluatedCode', true));
+        $this->assertTrue(class_exists(Fixtures\DefinitionInEvaluatedCode::class, true));
     }
 }
 
@@ -333,11 +378,11 @@ class ClassLoader
     {
         $fixtureDir = __DIR__.\DIRECTORY_SEPARATOR.'Fixtures'.\DIRECTORY_SEPARATOR;
 
-        if (__NAMESPACE__.'\TestingUnsilencing' === $class) {
+        if (TestingUnsilencing::class === $class) {
             eval('-- parse error --');
-        } elseif (__NAMESPACE__.'\TestingStacking' === $class) {
+        } elseif (TestingStacking::class === $class) {
             eval('namespace '.__NAMESPACE__.'; class TestingStacking { function foo() {} }');
-        } elseif (__NAMESPACE__.'\TestingCaseMismatch' === $class) {
+        } elseif (TestingCaseMismatch::class === $class) {
             eval('namespace '.__NAMESPACE__.'; class TestingCaseMisMatch {}');
         } elseif (__NAMESPACE__.'\Fixtures\Psr4CaseMismatch' === $class) {
             return $fixtureDir.'psr4'.\DIRECTORY_SEPARATOR.'Psr4CaseMismatch.php';
@@ -347,31 +392,57 @@ class ClassLoader
             return $fixtureDir.'notPsr0Bis.php';
         } elseif ('Symfony\Bridge\Debug\Tests\Fixtures\ExtendsDeprecatedParent' === $class) {
             eval('namespace Symfony\Bridge\Debug\Tests\Fixtures; class ExtendsDeprecatedParent extends \\'.__NAMESPACE__.'\Fixtures\DeprecatedClass {}');
-        } elseif ('Test\\'.__NAMESPACE__.'\DeprecatedParentClass' === $class) {
+        } elseif ('Test\\'.DeprecatedParentClass::class === $class) {
             eval('namespace Test\\'.__NAMESPACE__.'; class DeprecatedParentClass extends \\'.__NAMESPACE__.'\Fixtures\DeprecatedClass {}');
-        } elseif ('Test\\'.__NAMESPACE__.'\DeprecatedInterfaceClass' === $class) {
+        } elseif ('Test\\'.DeprecatedInterfaceClass::class === $class) {
             eval('namespace Test\\'.__NAMESPACE__.'; class DeprecatedInterfaceClass implements \\'.__NAMESPACE__.'\Fixtures\DeprecatedInterface {}');
-        } elseif ('Test\\'.__NAMESPACE__.'\NonDeprecatedInterfaceClass' === $class) {
+        } elseif ('Test\\'.NonDeprecatedInterfaceClass::class === $class) {
             eval('namespace Test\\'.__NAMESPACE__.'; class NonDeprecatedInterfaceClass implements \\'.__NAMESPACE__.'\Fixtures\NonDeprecatedInterface {}');
-        } elseif ('Test\\'.__NAMESPACE__.'\Float' === $class) {
+        } elseif ('Test\\'.Float::class === $class) {
             eval('namespace Test\\'.__NAMESPACE__.'; class Float {}');
-        } elseif (0 === strpos($class, 'Test\\'.__NAMESPACE__.'\ExtendsFinalClass')) {
+        } elseif (0 === strpos($class, 'Test\\'.ExtendsFinalClass::class)) {
             $classShortName = substr($class, strrpos($class, '\\') + 1);
             eval('namespace Test\\'.__NAMESPACE__.'; class '.$classShortName.' extends \\'.__NAMESPACE__.'\Fixtures\\'.substr($classShortName, 7).' {}');
-        } elseif ('Test\\'.__NAMESPACE__.'\ExtendsAnnotatedClass' === $class) {
+        } elseif ('Test\\'.ExtendsAnnotatedClass::class === $class) {
             eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsAnnotatedClass extends \\'.__NAMESPACE__.'\Fixtures\AnnotatedClass {
                 public function deprecatedMethod() { }
             }');
-        } elseif ('Test\\'.__NAMESPACE__.'\ExtendsInternals' === $class) {
+        } elseif ('Test\\'.ExtendsInternals::class === $class) {
             eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsInternals extends ExtendsInternalsParent {
                 use \\'.__NAMESPACE__.'\Fixtures\InternalTrait;
 
                 public function internalMethod() { }
             }');
-        } elseif ('Test\\'.__NAMESPACE__.'\ExtendsInternalsParent' === $class) {
+        } elseif ('Test\\'.ExtendsInternalsParent::class === $class) {
             eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsInternalsParent extends \\'.__NAMESPACE__.'\Fixtures\InternalClass implements \\'.__NAMESPACE__.'\Fixtures\InternalInterface { }');
-        } elseif ('Test\\'.__NAMESPACE__.'\UseTraitWithInternalMethod' === $class) {
+        } elseif ('Test\\'.UseTraitWithInternalMethod::class === $class) {
             eval('namespace Test\\'.__NAMESPACE__.'; class UseTraitWithInternalMethod { use \\'.__NAMESPACE__.'\Fixtures\TraitWithInternalMethod; }');
+        } elseif ('Test\\'.ExtendsVirtual::class === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsVirtual extends ExtendsVirtualParent implements \\'.__NAMESPACE__.'\Fixtures\VirtualSubInterface {
+                public function ownClassMethod() { }
+                public function classMethod() { }
+                public function sameLineInterfaceMethodNoBraces() { }
+            }');
+        } elseif ('Test\\'.ExtendsVirtualParent::class === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsVirtualParent extends ExtendsVirtualAbstract {
+                public function ownParentMethod() { }
+                public function traitMethod() { }
+                public function sameLineInterfaceMethod() { }
+                public function staticMethodNoBraces() { } // should be static
+            }');
+        } elseif ('Test\\'.ExtendsVirtualAbstract::class === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; abstract class ExtendsVirtualAbstract extends ExtendsVirtualAbstractBase {
+                public static function staticMethod() { }
+                public function ownAbstractMethod() { }
+                public function interfaceMethod() { }
+            }');
+        } elseif ('Test\\'.ExtendsVirtualAbstractBase::class === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; abstract class ExtendsVirtualAbstractBase extends \\'.__NAMESPACE__.'\Fixtures\VirtualClass implements \\'.__NAMESPACE__.'\Fixtures\VirtualInterface {
+                public function ownAbstractBaseMethod() { }
+            }');
+        } elseif ('Test\\'.ExtendsVirtualMagicCall::class === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsVirtualMagicCall extends \\'.__NAMESPACE__.'\Fixtures\VirtualClassMagicCall implements \\'.__NAMESPACE__.'\Fixtures\VirtualInterface {
+            }');
         }
     }
 }

Tests/ErrorHandlerTest.php

@@ -12,10 +12,12 @@
 namespace Symfony\Component\Debug\Tests;
 
 use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
 use Psr\Log\LogLevel;
 use Psr\Log\NullLogger;
 use Symfony\Component\Debug\BufferingLogger;
 use Symfony\Component\Debug\ErrorHandler;
+use Symfony\Component\Debug\Exception\ClassNotFoundException;
 use Symfony\Component\Debug\Exception\SilencedErrorContext;
 use Symfony\Component\Debug\Tests\Fixtures\ErrorHandlerThatUsesThePreviousOne;
 use Symfony\Component\Debug\Tests\Fixtures\LoggerThatSetAnErrorHandler;
@@ -25,6 +27,8 @@ use Symfony\Component\Debug\Tests\Fixtures\LoggerThatSetAnErrorHandler;
  *
  * @author Robert Schönthal <seroscho@googlemail.com>
  * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @group legacy
  */
 class ErrorHandlerTest extends TestCase
 {
@@ -33,7 +37,7 @@ class ErrorHandlerTest extends TestCase
         $handler = ErrorHandler::register();
 
         try {
-            $this->assertInstanceOf('Symfony\Component\Debug\ErrorHandler', $handler);
+            $this->assertInstanceOf(ErrorHandler::class, $handler);
             $this->assertSame($handler, ErrorHandler::register());
 
             $newHandler = new ErrorHandler();
@@ -70,15 +74,15 @@ class ErrorHandlerTest extends TestCase
 
     public function testErrorGetLast()
     {
-        $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+        $logger = $this->createMock(LoggerInterface::class);
         $handler = ErrorHandler::register();
         $handler->setDefaultLogger($logger);
-        $handler->screamAt(E_ALL);
+        $handler->screamAt(\E_ALL);
 
         try {
-            @trigger_error('Hello', E_USER_WARNING);
+            @trigger_error('Hello', \E_USER_WARNING);
             $expected = [
-                'type' => E_USER_WARNING,
+                'type' => \E_USER_WARNING,
                 'message' => 'Hello',
                 'file' => __FILE__,
                 'line' => __LINE__ - 5,
@@ -101,9 +105,14 @@ class ErrorHandlerTest extends TestCase
             $this->fail('ErrorException expected');
         } catch (\ErrorException $exception) {
             // if an exception is thrown, the test passed
-            $this->assertEquals(E_NOTICE, $exception->getSeverity());
+            if (\PHP_VERSION_ID < 80000) {
+                $this->assertEquals(\E_NOTICE, $exception->getSeverity());
+                $this->assertMatchesRegularExpression('/^Notice: Undefined variable: (foo|bar)/', $exception->getMessage());
+            } else {
+                $this->assertEquals(\E_WARNING, $exception->getSeverity());
+                $this->assertMatchesRegularExpression('/^Warning: Undefined variable \$(foo|bar)/', $exception->getMessage());
+            }
             $this->assertEquals(__FILE__, $exception->getFile());
-            $this->assertRegExp('/^Notice: Undefined variable: (foo|bar)/', $exception->getMessage());
 
             $trace = $exception->getTrace();
 
@@ -133,7 +142,7 @@ class ErrorHandlerTest extends TestCase
         try {
             $handler = ErrorHandler::register();
             $handler->throwAt(3, true);
-            $this->assertEquals(3 | E_RECOVERABLE_ERROR | E_USER_ERROR, $handler->throwAt(0));
+            $this->assertEquals(3 | \E_RECOVERABLE_ERROR | \E_USER_ERROR, $handler->throwAt(0));
         } finally {
             restore_error_handler();
             restore_exception_handler();
@@ -143,28 +152,28 @@ class ErrorHandlerTest extends TestCase
     public function testDefaultLogger()
     {
         try {
-            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+            $logger = $this->createMock(LoggerInterface::class);
             $handler = ErrorHandler::register();
 
-            $handler->setDefaultLogger($logger, E_NOTICE);
-            $handler->setDefaultLogger($logger, [E_USER_NOTICE => LogLevel::CRITICAL]);
+            $handler->setDefaultLogger($logger, \E_NOTICE);
+            $handler->setDefaultLogger($logger, [\E_USER_NOTICE => LogLevel::CRITICAL]);
 
             $loggers = [
-                E_DEPRECATED => [null, LogLevel::INFO],
-                E_USER_DEPRECATED => [null, LogLevel::INFO],
-                E_NOTICE => [$logger, LogLevel::WARNING],
-                E_USER_NOTICE => [$logger, LogLevel::CRITICAL],
-                E_STRICT => [null, LogLevel::WARNING],
-                E_WARNING => [null, LogLevel::WARNING],
-                E_USER_WARNING => [null, LogLevel::WARNING],
-                E_COMPILE_WARNING => [null, LogLevel::WARNING],
-                E_CORE_WARNING => [null, LogLevel::WARNING],
-                E_USER_ERROR => [null, LogLevel::CRITICAL],
-                E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],
-                E_COMPILE_ERROR => [null, LogLevel::CRITICAL],
-                E_PARSE => [null, LogLevel::CRITICAL],
-                E_ERROR => [null, LogLevel::CRITICAL],
-                E_CORE_ERROR => [null, LogLevel::CRITICAL],
+                \E_DEPRECATED => [null, LogLevel::INFO],
+                \E_USER_DEPRECATED => [null, LogLevel::INFO],
+                \E_NOTICE => [$logger, LogLevel::WARNING],
+                \E_USER_NOTICE => [$logger, LogLevel::CRITICAL],
+                \E_STRICT => [null, LogLevel::WARNING],
+                \E_WARNING => [null, LogLevel::WARNING],
+                \E_USER_WARNING => [null, LogLevel::WARNING],
+                \E_COMPILE_WARNING => [null, LogLevel::WARNING],
+                \E_CORE_WARNING => [null, LogLevel::WARNING],
+                \E_USER_ERROR => [null, LogLevel::CRITICAL],
+                \E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],
+                \E_COMPILE_ERROR => [null, LogLevel::CRITICAL],
+                \E_PARSE => [null, LogLevel::CRITICAL],
+                \E_ERROR => [null, LogLevel::CRITICAL],
+                \E_CORE_ERROR => [null, LogLevel::CRITICAL],
             ];
             $this->assertSame($loggers, $handler->setLoggers([]));
         } finally {
@@ -205,20 +214,20 @@ class ErrorHandlerTest extends TestCase
             restore_exception_handler();
 
             $handler = ErrorHandler::register();
-            $handler->throwAt(E_USER_DEPRECATED, true);
-            $this->assertFalse($handler->handleError(E_USER_DEPRECATED, 'foo', 'foo.php', 12, []));
+            $handler->throwAt(\E_USER_DEPRECATED, true);
+            $this->assertFalse($handler->handleError(\E_USER_DEPRECATED, 'foo', 'foo.php', 12, []));
 
             restore_error_handler();
             restore_exception_handler();
 
             $handler = ErrorHandler::register();
-            $handler->throwAt(E_DEPRECATED, true);
-            $this->assertFalse($handler->handleError(E_DEPRECATED, 'foo', 'foo.php', 12, []));
+            $handler->throwAt(\E_DEPRECATED, true);
+            $this->assertFalse($handler->handleError(\E_DEPRECATED, 'foo', 'foo.php', 12, []));
 
             restore_error_handler();
             restore_exception_handler();
 
-            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+            $logger = $this->createMock(LoggerInterface::class);
 
             $warnArgCheck = function ($logLevel, $message, $context) {
                 $this->assertEquals('info', $logLevel);
@@ -227,7 +236,7 @@ class ErrorHandlerTest extends TestCase
                 $exception = $context['exception'];
                 $this->assertInstanceOf(\ErrorException::class, $exception);
                 $this->assertSame('User Deprecated: foo', $exception->getMessage());
-                $this->assertSame(E_USER_DEPRECATED, $exception->getSeverity());
+                $this->assertSame(\E_USER_DEPRECATED, $exception->getSeverity());
             };
 
             $logger
@@ -237,21 +246,27 @@ class ErrorHandlerTest extends TestCase
             ;
 
             $handler = ErrorHandler::register();
-            $handler->setDefaultLogger($logger, E_USER_DEPRECATED);
-            $this->assertTrue($handler->handleError(E_USER_DEPRECATED, 'foo', 'foo.php', 12, []));
+            $handler->setDefaultLogger($logger, \E_USER_DEPRECATED);
+            $this->assertTrue($handler->handleError(\E_USER_DEPRECATED, 'foo', 'foo.php', 12, []));
 
             restore_error_handler();
             restore_exception_handler();
 
-            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+            $logger = $this->createMock(LoggerInterface::class);
 
             $line = null;
             $logArgCheck = function ($level, $message, $context) use (&$line) {
-                $this->assertEquals('Notice: Undefined variable: undefVar', $message);
                 $this->assertArrayHasKey('exception', $context);
                 $exception = $context['exception'];
+
+                if (\PHP_VERSION_ID < 80000) {
+                    $this->assertEquals('Notice: Undefined variable: undefVar', $message);
+                    $this->assertSame(\E_NOTICE, $exception->getSeverity());
+                } else {
+                    $this->assertEquals('Warning: Undefined variable $undefVar', $message);
+                    $this->assertSame(\E_WARNING, $exception->getSeverity());
+                }
                 $this->assertInstanceOf(SilencedErrorContext::class, $exception);
-                $this->assertSame(E_NOTICE, $exception->getSeverity());
                 $this->assertSame(__FILE__, $exception->getFile());
                 $this->assertSame($line, $exception->getLine());
                 $this->assertNotEmpty($exception->getTrace());
@@ -265,8 +280,13 @@ class ErrorHandlerTest extends TestCase
             ;
 
             $handler = ErrorHandler::register();
-            $handler->setDefaultLogger($logger, E_NOTICE);
-            $handler->screamAt(E_NOTICE);
+            if (\PHP_VERSION_ID < 80000) {
+                $handler->setDefaultLogger($logger, \E_NOTICE);
+                $handler->screamAt(\E_NOTICE);
+            } else {
+                $handler->setDefaultLogger($logger, \E_WARNING);
+                $handler->screamAt(\E_WARNING);
+            }
             unset($undefVar);
             $line = __LINE__ + 1;
             @$undefVar++;
@@ -283,6 +303,10 @@ class ErrorHandlerTest extends TestCase
 
     public function testHandleUserError()
     {
+        if (\PHP_VERSION_ID >= 70400) {
+            $this->markTestSkipped('PHP 7.4 allows __toString to throw exceptions');
+        }
+
         try {
             $handler = ErrorHandler::register();
             $handler->throwAt(0, true);
@@ -303,6 +327,26 @@ class ErrorHandlerTest extends TestCase
         }
     }
 
+    public function testHandleErrorWithAnonymousClass()
+    {
+        $handler = ErrorHandler::register();
+        $handler->throwAt(\E_USER_WARNING, true);
+        try {
+            $handler->handleError(\E_USER_WARNING, 'foo '.\get_class(new class() extends \stdClass {
+            }).' bar', 'foo.php', 12);
+            $this->fail('Exception expected.');
+        } catch (\ErrorException $e) {
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+
+        $this->assertSame('User Warning: foo stdClass@anonymous bar', $e->getMessage());
+        $this->assertSame(\E_USER_WARNING, $e->getSeverity());
+        $this->assertSame('foo.php', $e->getFile());
+        $this->assertSame(12, $e->getLine());
+    }
+
     public function testHandleDeprecation()
     {
         $logArgCheck = function ($level, $message, $context) {
@@ -313,7 +357,7 @@ class ErrorHandlerTest extends TestCase
             $this->assertSame('User Deprecated: Foo deprecation', $exception->getMessage());
         };
 
-        $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+        $logger = $this->createMock(LoggerInterface::class);
         $logger
             ->expects($this->once())
             ->method('log')
@@ -322,15 +366,13 @@ class ErrorHandlerTest extends TestCase
 
         $handler = new ErrorHandler();
         $handler->setDefaultLogger($logger);
-        @$handler->handleError(E_USER_DEPRECATED, 'Foo deprecation', __FILE__, __LINE__, []);
-
-        restore_error_handler();
+        @$handler->handleError(\E_USER_DEPRECATED, 'Foo deprecation', __FILE__, __LINE__, []);
     }
 
     public function testHandleException()
     {
         try {
-            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+            $logger = $this->createMock(LoggerInterface::class);
             $handler = ErrorHandler::register();
 
             $exception = new \Exception('foo');
@@ -347,7 +389,7 @@ class ErrorHandlerTest extends TestCase
                 ->willReturnCallback($logArgCheck)
             ;
 
-            $handler->setDefaultLogger($logger, E_ERROR);
+            $handler->setDefaultLogger($logger, \E_ERROR);
 
             try {
                 $handler->handleException($exception);
@@ -373,26 +415,26 @@ class ErrorHandlerTest extends TestCase
         $handler = new ErrorHandler($bootLogger);
 
         $loggers = [
-            E_DEPRECATED => [$bootLogger, LogLevel::INFO],
-            E_USER_DEPRECATED => [$bootLogger, LogLevel::INFO],
-            E_NOTICE => [$bootLogger, LogLevel::WARNING],
-            E_USER_NOTICE => [$bootLogger, LogLevel::WARNING],
-            E_STRICT => [$bootLogger, LogLevel::WARNING],
-            E_WARNING => [$bootLogger, LogLevel::WARNING],
-            E_USER_WARNING => [$bootLogger, LogLevel::WARNING],
-            E_COMPILE_WARNING => [$bootLogger, LogLevel::WARNING],
-            E_CORE_WARNING => [$bootLogger, LogLevel::WARNING],
-            E_USER_ERROR => [$bootLogger, LogLevel::CRITICAL],
-            E_RECOVERABLE_ERROR => [$bootLogger, LogLevel::CRITICAL],
-            E_COMPILE_ERROR => [$bootLogger, LogLevel::CRITICAL],
-            E_PARSE => [$bootLogger, LogLevel::CRITICAL],
-            E_ERROR => [$bootLogger, LogLevel::CRITICAL],
-            E_CORE_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_DEPRECATED => [$bootLogger, LogLevel::INFO],
+            \E_USER_DEPRECATED => [$bootLogger, LogLevel::INFO],
+            \E_NOTICE => [$bootLogger, LogLevel::WARNING],
+            \E_USER_NOTICE => [$bootLogger, LogLevel::WARNING],
+            \E_STRICT => [$bootLogger, LogLevel::WARNING],
+            \E_WARNING => [$bootLogger, LogLevel::WARNING],
+            \E_USER_WARNING => [$bootLogger, LogLevel::WARNING],
+            \E_COMPILE_WARNING => [$bootLogger, LogLevel::WARNING],
+            \E_CORE_WARNING => [$bootLogger, LogLevel::WARNING],
+            \E_USER_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_RECOVERABLE_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_COMPILE_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_PARSE => [$bootLogger, LogLevel::CRITICAL],
+            \E_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_CORE_ERROR => [$bootLogger, LogLevel::CRITICAL],
         ];
 
         $this->assertSame($loggers, $handler->setLoggers([]));
 
-        $handler->handleError(E_DEPRECATED, 'Foo message', __FILE__, 123, []);
+        $handler->handleError(\E_DEPRECATED, 'Foo message', __FILE__, 123, []);
 
         $logs = $bootLogger->cleanLogs();
 
@@ -406,16 +448,16 @@ class ErrorHandlerTest extends TestCase
         $this->assertSame('Deprecated: Foo message', $exception->getMessage());
         $this->assertSame(__FILE__, $exception->getFile());
         $this->assertSame(123, $exception->getLine());
-        $this->assertSame(E_DEPRECATED, $exception->getSeverity());
+        $this->assertSame(\E_DEPRECATED, $exception->getSeverity());
 
         $bootLogger->log(LogLevel::WARNING, 'Foo message', ['exception' => $exception]);
 
-        $mockLogger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+        $mockLogger = $this->createMock(LoggerInterface::class);
         $mockLogger->expects($this->once())
             ->method('log')
             ->with(LogLevel::WARNING, 'Foo message', ['exception' => $exception]);
 
-        $handler->setLoggers([E_DEPRECATED => [$mockLogger, LogLevel::WARNING]]);
+        $handler->setLoggers([\E_DEPRECATED => [$mockLogger, LogLevel::WARNING]]);
     }
 
     public function testSettingLoggerWhenExceptionIsBuffered()
@@ -425,7 +467,7 @@ class ErrorHandlerTest extends TestCase
 
         $exception = new \Exception('Foo message');
 
-        $mockLogger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+        $mockLogger = $this->createMock(LoggerInterface::class);
         $mockLogger->expects($this->once())
             ->method('log')
             ->with(LogLevel::CRITICAL, 'Uncaught Exception: Foo message', ['exception' => $exception]);
@@ -440,11 +482,11 @@ class ErrorHandlerTest extends TestCase
     public function testHandleFatalError()
     {
         try {
-            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+            $logger = $this->createMock(LoggerInterface::class);
             $handler = ErrorHandler::register();
 
             $error = [
-                'type' => E_PARSE,
+                'type' => \E_PARSE,
                 'message' => 'foo',
                 'file' => 'bar',
                 'line' => 123,
@@ -462,7 +504,7 @@ class ErrorHandlerTest extends TestCase
                 ->willReturnCallback($logArgCheck)
             ;
 
-            $handler->setDefaultLogger($logger, E_PARSE);
+            $handler->setDefaultLogger($logger, \E_PARSE);
 
             $handler->handleFatalError($error);
 
@@ -487,15 +529,13 @@ class ErrorHandlerTest extends TestCase
 
         $handler->handleException($exception);
 
-        $this->assertInstanceOf('Symfony\Component\Debug\Exception\ClassNotFoundException', $args[0]);
+        $this->assertInstanceOf(ClassNotFoundException::class, $args[0]);
         $this->assertStringStartsWith("Attempted to load class \"IReallyReallyDoNotExistAnywhereInTheRepositoryISwear\" from the global namespace.\nDid you forget a \"use\" statement", $args[0]->getMessage());
     }
 
-    /**
-     * @expectedException \Exception
-     */
     public function testCustomExceptionHandler()
     {
+        $this->expectException(\Exception::class);
         $handler = new ErrorHandler();
         $handler->setExceptionHandler(function ($e) use ($handler) {
             $handler->handleException($e);
@@ -523,8 +563,8 @@ class ErrorHandlerTest extends TestCase
                 $handler = ErrorHandlerThatUsesThePreviousOne::register();
             }
 
-            @trigger_error('foo', E_USER_DEPRECATED);
-            @trigger_error('bar', E_USER_DEPRECATED);
+            @trigger_error('foo', \E_USER_DEPRECATED);
+            @trigger_error('bar', \E_USER_DEPRECATED);
 
             $this->assertSame([$handler, 'handleError'], set_error_handler('var_dump'));
 

Tests/Exception/FlattenExceptionTest.php

@@ -30,6 +30,9 @@ use Symfony\Component\HttpKernel\Exception\TooManyRequestsHttpException;
 use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;
 use Symfony\Component\HttpKernel\Exception\UnsupportedMediaTypeHttpException;
 
+/**
+ * @group legacy
+ */
 class FlattenExceptionTest extends TestCase
 {
     public function testStatusCode()
@@ -171,9 +174,9 @@ class FlattenExceptionTest extends TestCase
 
         $flattened = FlattenException::create($exception)->getPrevious();
 
-        $this->assertEquals($flattened->getMessage(), 'Oh noes!', 'The message is copied from the original exception.');
-        $this->assertEquals($flattened->getCode(), 42, 'The code is copied from the original exception.');
-        $this->assertEquals($flattened->getClass(), 'ParseError', 'The class is set to the class of the original exception');
+        $this->assertEquals('Oh noes!', $flattened->getMessage(), 'The message is copied from the original exception.');
+        $this->assertEquals(42, $flattened->getCode(), 'The code is copied from the original exception.');
+        $this->assertEquals('ParseError', $flattened->getClass(), 'The class is set to the class of the original exception');
     }
 
     /**
@@ -237,6 +240,10 @@ class FlattenExceptionTest extends TestCase
 
     public function testArguments()
     {
+        if (\PHP_VERSION_ID >= 70400) {
+            $this->markTestSkipped('PHP 7.4 removes arguments from exception traces.');
+        }
+
         $dh = opendir(__DIR__);
         $fh = tmpfile();
 
@@ -258,8 +265,8 @@ class FlattenExceptionTest extends TestCase
             0.0,
             '0',
             '',
-            INF,
-            NAN,
+            \INF,
+            \NAN,
         ]);
 
         $flattened = FlattenException::create($exception);
@@ -279,7 +286,7 @@ class FlattenExceptionTest extends TestCase
 
         $args = $array[$i++];
         $this->assertSame($args[0], 'object');
-        $this->assertTrue('Closure' === $args[1] || is_subclass_of($args[1], '\Closure'), 'Expect object class name to be Closure or a subclass of Closure.');
+        $this->assertTrue('Closure' === $args[1] || is_subclass_of($args[1], \Closure::class), 'Expect object class name to be Closure or a subclass of Closure.');
 
         $this->assertSame(['array', [['integer', 1], ['integer', 2]]], $array[$i++]);
         $this->assertSame(['array', ['foo' => ['integer', 123]]], $array[$i++]);
@@ -290,26 +297,34 @@ class FlattenExceptionTest extends TestCase
         $this->assertSame(['float', 0.0], $array[$i++]);
         $this->assertSame(['string', '0'], $array[$i++]);
         $this->assertSame(['string', ''], $array[$i++]);
-        $this->assertSame(['float', INF], $array[$i++]);
+        $this->assertSame(['float', \INF], $array[$i++]);
 
         // assertEquals() does not like NAN values.
-        $this->assertEquals($array[$i][0], 'float');
-        $this->assertTrue(is_nan($array[$i++][1]));
+        $this->assertEquals('float', $array[$i][0]);
+        $this->assertNan($array[$i][1]);
     }
 
     public function testRecursionInArguments()
     {
+        if (\PHP_VERSION_ID >= 70400) {
+            $this->markTestSkipped('PHP 7.4 removes arguments from exception traces.');
+        }
+
         $a = null;
         $a = ['foo', [2, &$a]];
         $exception = $this->createException($a);
 
         $flattened = FlattenException::create($exception);
         $trace = $flattened->getTrace();
-        $this->assertContains('*DEEP NESTED ARRAY*', serialize($trace));
+        $this->assertStringContainsString('*DEEP NESTED ARRAY*', serialize($trace));
     }
 
     public function testTooBigArray()
     {
+        if (\PHP_VERSION_ID >= 70400) {
+            $this->markTestSkipped('PHP 7.4 removes arguments from exception traces.');
+        }
+
         $a = [];
         for ($i = 0; $i < 20; ++$i) {
             for ($j = 0; $j < 50; ++$j) {
@@ -329,8 +344,8 @@ class FlattenExceptionTest extends TestCase
 
         $serializeTrace = serialize($trace);
 
-        $this->assertContains('*SKIPPED over 10000 entries*', $serializeTrace);
-        $this->assertNotContains('*value1*', $serializeTrace);
+        $this->assertStringContainsString('*SKIPPED over 10000 entries*', $serializeTrace);
+        $this->assertStringNotContainsString('*value1*', $serializeTrace);
     }
 
     public function testAnonymousClass()
@@ -340,12 +355,52 @@ class FlattenExceptionTest extends TestCase
 
         $this->assertSame('RuntimeException@anonymous', $flattened->getClass());
 
+        $flattened->setClass(\get_class(new class('Oops') extends NotFoundHttpException {
+        }));
+
+        $this->assertSame('Symfony\Component\HttpKernel\Exception\NotFoundHttpException@anonymous', $flattened->getClass());
+
         $flattened = FlattenException::create(new \Exception(sprintf('Class "%s" blah.', \get_class(new class() extends \RuntimeException {
         }))));
 
         $this->assertSame('Class "RuntimeException@anonymous" blah.', $flattened->getMessage());
     }
 
+    public function testToStringEmptyMessage()
+    {
+        $exception = new \RuntimeException();
+
+        $flattened = FlattenException::create($exception);
+
+        $this->assertSame($exception->getTraceAsString(), $flattened->getTraceAsString());
+        $this->assertSame($exception->__toString(), $flattened->getAsString());
+    }
+
+    public function testToString()
+    {
+        $test = function ($a, $b, $c, $d) {
+            return new \RuntimeException('This is a test message');
+        };
+
+        $exception = $test('foo123', 1, null, 1.5);
+
+        $flattened = FlattenException::create($exception);
+
+        $this->assertSame($exception->getTraceAsString(), $flattened->getTraceAsString());
+        $this->assertSame($exception->__toString(), $flattened->getAsString());
+    }
+
+    public function testToStringParent()
+    {
+        $exception = new \LogicException('This is message 1');
+        $exception = new \RuntimeException('This is messsage 2', 500, $exception);
+
+        $flattened = FlattenException::create($exception);
+
+        $this->assertSame($exception->getTraceAsString(), $flattened->getTraceAsString());
+        $this->assertSame($exception->__toString(), $flattened->getAsString());
+    }
+
     private function createException($foo)
     {
         return new \Exception();

Tests/ExceptionHandlerTest.php

@@ -19,18 +19,24 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 
 require_once __DIR__.'/HeaderMock.php';
 
+/**
+ * @group legacy
+ */
 class ExceptionHandlerTest extends TestCase
 {
-    protected function setUp()
+    protected function setUp(): void
     {
         testHeader();
     }
 
-    protected function tearDown()
+    protected function tearDown(): void
     {
         testHeader();
     }
 
+    /**
+     * @group legacy
+     */
     public function testDebug()
     {
         $handler = new ExceptionHandler(false);
@@ -39,8 +45,8 @@ class ExceptionHandlerTest extends TestCase
         $handler->sendPhpResponse(new \RuntimeException('Foo'));
         $response = ob_get_clean();
 
-        $this->assertContains('Whoops, looks like something went wrong.', $response);
-        $this->assertNotContains('<div class="trace trace-as-html">', $response);
+        $this->assertStringContainsString('Whoops, looks like something went wrong.', $response);
+        $this->assertStringNotContainsString('<div class="trace trace-as-html">', $response);
 
         $handler = new ExceptionHandler(true);
 
@@ -48,8 +54,17 @@ class ExceptionHandlerTest extends TestCase
         $handler->sendPhpResponse(new \RuntimeException('Foo'));
         $response = ob_get_clean();
 
-        $this->assertContains('Whoops, looks like something went wrong.', $response);
-        $this->assertContains('<div class="trace trace-as-html">', $response);
+        $this->assertStringContainsString('<h1 class="break-long-words exception-message">Foo</h1>', $response);
+        $this->assertStringContainsString('<div class="trace trace-as-html">', $response);
+
+        // taken from https://www.owasp.org/index.php/Cross-site_Scripting_(XSS)
+        $htmlWithXss = '<body onload=alert(\'test1\')> <b onmouseover=alert(\'Wufff!\')>click me!</b> <img src="j&#X41vascript:alert(\'test2\')"> <meta http-equiv="refresh"
+content="0;url=data:text/html;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg">';
+        ob_start();
+        $handler->sendPhpResponse(new \RuntimeException($htmlWithXss));
+        $response = ob_get_clean();
+
+        $this->assertStringContainsString(sprintf('<h1 class="break-long-words exception-message">%s</h1>', htmlspecialchars($htmlWithXss, \ENT_COMPAT | \ENT_SUBSTITUTE, 'UTF-8')), $response);
     }
 
     public function testStatusCode()
@@ -60,7 +75,7 @@ class ExceptionHandlerTest extends TestCase
         $handler->sendPhpResponse(new NotFoundHttpException('Foo'));
         $response = ob_get_clean();
 
-        $this->assertContains('Sorry, the page you are looking for could not be found.', $response);
+        $this->assertStringContainsString('Sorry, the page you are looking for could not be found.', $response);
 
         $expectedHeaders = [
             ['HTTP/1.0 404', true, null],
@@ -116,7 +131,7 @@ class ExceptionHandlerTest extends TestCase
         });
 
         $handler->handle(new \Exception());
-        ob_end_flush(); // Necessary because of this PHP bug : https://bugs.php.net/bug.php?id=76563
+        ob_end_flush(); // Necessary because of this PHP bug : https://bugs.php.net/76563
         $this->assertSame('ccc', ob_get_clean());
     }
 
@@ -150,14 +165,14 @@ class ExceptionHandlerTest extends TestCase
             $this->fail('OutOfMemoryException should bypass the handler');
         });
 
-        $handler->handle(new OutOfMemoryException('foo', 0, E_ERROR, __FILE__, __LINE__));
+        $handler->handle(new OutOfMemoryException('foo', 0, \E_ERROR, __FILE__, __LINE__));
 
         $this->assertThatTheExceptionWasOutput(ob_get_clean(), OutOfMemoryException::class, 'OutOfMemoryException', 'foo');
     }
 
     private function assertThatTheExceptionWasOutput($content, $expectedClass, $expectedTitle, $expectedMessage)
     {
-        $this->assertContains(sprintf('<span class="exception_title"><abbr title="%s">%s</abbr></span>', $expectedClass, $expectedTitle), $content);
-        $this->assertContains(sprintf('<p class="break-long-words trace-message">%s</p>', $expectedMessage), $content);
+        $this->assertStringContainsString(sprintf('<span class="exception_title"><abbr title="%s">%s</abbr></span>', $expectedClass, $expectedTitle), $content);
+        $this->assertStringContainsString(sprintf('<p class="break-long-words trace-message">%s</p>', $expectedMessage), $content);
     }
 }

Tests/FatalErrorHandler/ClassNotFoundFatalErrorHandlerTest.php

@@ -14,12 +14,16 @@ namespace Symfony\Component\Debug\Tests\FatalErrorHandler;
 use Composer\Autoload\ClassLoader as ComposerClassLoader;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Debug\DebugClassLoader;
+use Symfony\Component\Debug\Exception\ClassNotFoundException;
 use Symfony\Component\Debug\Exception\FatalErrorException;
 use Symfony\Component\Debug\FatalErrorHandler\ClassNotFoundFatalErrorHandler;
 
+/**
+ * @group legacy
+ */
 class ClassNotFoundFatalErrorHandlerTest extends TestCase
 {
-    public static function setUpBeforeClass()
+    public static function setUpBeforeClass(): void
     {
         foreach (spl_autoload_functions() as $function) {
             if (!\is_array($function)) {
@@ -29,10 +33,14 @@ class ClassNotFoundFatalErrorHandlerTest extends TestCase
             // get class loaders wrapped by DebugClassLoader
             if ($function[0] instanceof DebugClassLoader) {
                 $function = $function[0]->getClassLoader();
+
+                if (!\is_array($function)) {
+                    continue;
+                }
             }
 
             if ($function[0] instanceof ComposerClassLoader) {
-                $function[0]->add('Symfony_Component_Debug_Tests_Fixtures', \dirname(\dirname(\dirname(\dirname(\dirname(__DIR__))))));
+                $function[0]->add('Symfony_Component_Debug_Tests_Fixtures', \dirname(__DIR__, 5));
                 break;
             }
         }
@@ -60,8 +68,8 @@ class ClassNotFoundFatalErrorHandlerTest extends TestCase
             array_map('spl_autoload_register', $autoloaders);
         }
 
-        $this->assertInstanceOf('Symfony\Component\Debug\Exception\ClassNotFoundException', $exception);
-        $this->assertRegExp($translatedMessage, $exception->getMessage());
+        $this->assertInstanceOf(ClassNotFoundException::class, $exception);
+        $this->assertMatchesRegularExpression($translatedMessage, $exception->getMessage());
         $this->assertSame($error['type'], $exception->getSeverity());
         $this->assertSame($error['file'], $exception->getFile());
         $this->assertSame($error['line'], $exception->getLine());
@@ -76,6 +84,15 @@ class ClassNotFoundFatalErrorHandlerTest extends TestCase
         $debugClassLoader = new DebugClassLoader([$autoloader, 'loadClass']);
 
         return [
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class "WhizBangFactory" not found',
+                ],
+                "/^Attempted to load class \"WhizBangFactory\" from the global namespace.\nDid you forget a \"use\" statement\?$/",
+            ],
             [
                 [
                     'type' => 1,
@@ -94,6 +111,33 @@ class ClassNotFoundFatalErrorHandlerTest extends TestCase
                 ],
                 "/^Attempted to load class \"WhizBangFactory\" from namespace \"Foo\\\\Bar\".\nDid you forget a \"use\" statement for another namespace\?$/",
             ],
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class "Foo\\Bar\\WhizBangFactory" not found',
+                ],
+                "/^Attempted to load class \"WhizBangFactory\" from namespace \"Foo\\\\Bar\".\nDid you forget a \"use\" statement for another namespace\?$/",
+            ],
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Interface "Foo\\Bar\\WhizBangInterface" not found',
+                ],
+                "/^Attempted to load interface \"WhizBangInterface\" from namespace \"Foo\\\\Bar\".\nDid you forget a \"use\" statement for another namespace\?$/",
+            ],
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Trait "Foo\\Bar\\WhizBangTrait" not found',
+                ],
+                "/^Attempted to load trait \"WhizBangTrait\" from namespace \"Foo\\\\Bar\".\nDid you forget a \"use\" statement for another namespace\?$/",
+            ],
             [
                 [
                     'type' => 1,
@@ -175,6 +219,6 @@ class ClassNotFoundFatalErrorHandlerTest extends TestCase
         $handler = new ClassNotFoundFatalErrorHandler();
         $exception = $handler->handleError($error, new FatalErrorException('', 0, $error['type'], $error['file'], $error['line']));
 
-        $this->assertInstanceOf('Symfony\Component\Debug\Exception\ClassNotFoundException', $exception);
+        $this->assertInstanceOf(ClassNotFoundException::class, $exception);
     }
 }

Tests/FatalErrorHandler/UndefinedFunctionFatalErrorHandlerTest.php

@@ -13,8 +13,12 @@ namespace Symfony\Component\Debug\Tests\FatalErrorHandler;
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Debug\Exception\FatalErrorException;
+use Symfony\Component\Debug\Exception\UndefinedFunctionException;
 use Symfony\Component\Debug\FatalErrorHandler\UndefinedFunctionFatalErrorHandler;
 
+/**
+ * @group legacy
+ */
 class UndefinedFunctionFatalErrorHandlerTest extends TestCase
 {
     /**
@@ -25,7 +29,7 @@ class UndefinedFunctionFatalErrorHandlerTest extends TestCase
         $handler = new UndefinedFunctionFatalErrorHandler();
         $exception = $handler->handleError($error, new FatalErrorException('', 0, $error['type'], $error['file'], $error['line']));
 
-        $this->assertInstanceOf('Symfony\Component\Debug\Exception\UndefinedFunctionException', $exception);
+        $this->assertInstanceOf(UndefinedFunctionException::class, $exception);
         // class names are case insensitive and PHP do not return the same
         $this->assertSame(strtolower($translatedMessage), strtolower($exception->getMessage()));
         $this->assertSame($error['type'], $exception->getSeverity());

Tests/FatalErrorHandler/UndefinedMethodFatalErrorHandlerTest.php

@@ -13,8 +13,12 @@ namespace Symfony\Component\Debug\Tests\FatalErrorHandler;
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Debug\Exception\FatalErrorException;
+use Symfony\Component\Debug\Exception\UndefinedMethodException;
 use Symfony\Component\Debug\FatalErrorHandler\UndefinedMethodFatalErrorHandler;
 
+/**
+ * @group legacy
+ */
 class UndefinedMethodFatalErrorHandlerTest extends TestCase
 {
     /**
@@ -25,7 +29,7 @@ class UndefinedMethodFatalErrorHandlerTest extends TestCase
         $handler = new UndefinedMethodFatalErrorHandler();
         $exception = $handler->handleError($error, new FatalErrorException('', 0, $error['type'], $error['file'], $error['line']));
 
-        $this->assertInstanceOf('Symfony\Component\Debug\Exception\UndefinedMethodException', $exception);
+        $this->assertInstanceOf(UndefinedMethodException::class, $exception);
         $this->assertSame($translatedMessage, $exception->getMessage());
         $this->assertSame($error['type'], $exception->getSeverity());
         $this->assertSame($error['file'], $exception->getFile());
@@ -44,6 +48,15 @@ class UndefinedMethodFatalErrorHandlerTest extends TestCase
                 ],
                 'Attempted to call an undefined method named "what" of class "SplObjectStorage".',
             ],
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Call to undefined method SplObjectStorage::()',
+                ],
+                'Attempted to call an undefined method named "" of class "SplObjectStorage".',
+            ],
             [
                 [
                     'type' => 1,

Tests/Fixtures/ErrorHandlerThatUsesThePreviousOne.php

@@ -15,8 +15,8 @@ class ErrorHandlerThatUsesThePreviousOne
         return $handler;
     }
 
-    public function handleError($type, $message, $file, $line, $context)
+    public function handleError()
     {
-        return \call_user_func(self::$previous, $type, $message, $file, $line, $context);
+        return \call_user_func_array(self::$previous, \func_get_args());
     }
 }

Tests/Fixtures/FinalClasses.php

@@ -41,7 +41,6 @@ class FinalClass4
 /**
  * @author John Doe
  *
- *
  * @final multiline
  * comment
  */

Tests/Fixtures/InterfaceWithAnnotatedParameters.php

@@ -11,4 +11,17 @@ interface InterfaceWithAnnotatedParameters
      * @param bool $matrix
      */
     public function whereAmI();
+
+    /**
+     * @param       $noType
+     * @param callable(\Throwable|null $reason, mixed $value) $callback and a comment
+     * about this great param
+     * @param string                                          $param (comment with $dollar)
+     * @param $defined
+     * @param  callable  ($a,  $b)  $anotherOne
+     * @param callable (mixed $a, $b) $definedCallable
+     * @param Type$WithDollarIsStillAType $ccc
+     * @param \JustAType
+     */
+    public function iAmHere();
 }

Tests/Fixtures/LoggerThatSetAnErrorHandler.php

@@ -6,7 +6,7 @@ use Symfony\Component\Debug\BufferingLogger;
 
 class LoggerThatSetAnErrorHandler extends BufferingLogger
 {
-    public function log($level, $message, array $context = [])
+    public function log($level, $message, array $context = []): void
     {
         set_error_handler('is_string');
         parent::log($level, $message, $context);

Tests/Fixtures/SubClassWithAnnotatedParameters.php

@@ -21,4 +21,12 @@ class SubClassWithAnnotatedParameters extends ClassWithAnnotatedParameters imple
     public function whereAmI()
     {
     }
+
+    /**
+     * @param                      $defined
+     * @param Type\Does\Not\Matter $definedCallable
+     */
+    public function iAmHere()
+    {
+    }
 }

Tests/Fixtures/VirtualClass.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @method string classMethod()
+ */
+class VirtualClass
+{
+    use VirtualTrait;
+}

Tests/Fixtures/VirtualClassMagicCall.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @method string magicMethod()
+ * @method static string staticMagicMethod()
+ */
+class VirtualClassMagicCall
+{
+    public static function __callStatic($name, $arguments)
+    {
+    }
+
+    public function __call($name, $arguments)
+    {
+    }
+}

Tests/Fixtures/VirtualInterface.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @method string interfaceMethod()
+ * @method        sameLineInterfaceMethod($arg)
+ * @method sameLineInterfaceMethodNoBraces
+ *
+ * Ignored
+ * @method
+ * @method
+ *
+ * Not ignored
+ * @method newLineInterfaceMethod() Some description!
+ * @method \stdClass newLineInterfaceMethodNoBraces Description
+ *
+ * Invalid
+ * @method unknownType invalidInterfaceMethod()
+ * @method unknownType|string invalidInterfaceMethodNoBraces
+ *
+ * Complex
+ * @method              complexInterfaceMethod($arg, ...$args)
+ * @method string[]|int complexInterfaceMethodTyped($arg, int ...$args) Description ...
+ *
+ * Static
+ * @method static Foo&Bar staticMethod()
+ * @method static staticMethodNoBraces
+ * @method static \stdClass staticMethodTyped(int $arg) Description
+ * @method static \stdClass[] staticMethodTypedNoBraces
+ */
+interface VirtualInterface
+{
+}

Tests/Fixtures/VirtualSubInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @method string subInterfaceMethod()
+ */
+interface VirtualSubInterface extends VirtualInterface
+{
+}

Tests/Fixtures/VirtualTrait.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @method string traitMethod()
+ */
+trait VirtualTrait
+{
+}

Tests/Fixtures2/RequiredTwice.php

@@ -1,5 +1,14 @@
 <?php
 
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
 namespace Symfony\Component\Debug\Tests\Fixtures2;
 
 class RequiredTwice

Tests/phpt/debug_class_loader.phpt

@@ -23,5 +23,6 @@ class_exists(ExtendedFinalMethod::class);
 
 ?>
 --EXPECTF--
+%A
 The "Symfony\Component\Debug\Tests\Fixtures\FinalMethod::finalMethod()" method is considered final. It may change without further notice as of its next major version. You should not extend it from "Symfony\Component\Debug\Tests\Fixtures\ExtendedFinalMethod".
 The "Symfony\Component\Debug\Tests\Fixtures\FinalMethod::finalMethod2()" method is considered final. It may change without further notice as of its next major version. You should not extend it from "Symfony\Component\Debug\Tests\Fixtures\ExtendedFinalMethod".

Tests/phpt/decorate_exception_hander.phpt

@@ -26,6 +26,7 @@ if (true) {
 
 ?>
 --EXPECTF--
+%A
 object(Symfony\Component\Debug\Exception\ClassNotFoundException)#%d (8) {
   ["message":protected]=>
   string(131) "Attempted to load class "missing" from namespace "Symfony\Component\Debug".

Tests/phpt/exception_rethrown.phpt

@@ -14,7 +14,7 @@ require $vendor.'/vendor/autoload.php';
 if (true) {
     class TestLogger extends \Psr\Log\AbstractLogger
     {
-        public function log($level, $message, array $context = [])
+        public function log($level, $message, array $context = []): void
         {
             echo $message, "\n";
         }

Tests/phpt/fatal_with_nested_handlers.phpt

@@ -24,7 +24,7 @@ var_dump([
 $eHandler[0]->setExceptionHandler('print_r');
 
 if (true) {
-    class Broken implements \Serializable
+    class Broken implements \JsonSerializable
     {
     }
 }
@@ -35,8 +35,9 @@ array(1) {
   [0]=>
   string(37) "Error and exception handlers do match"
 }
+%A
 object(Symfony\Component\Debug\Exception\FatalErrorException)#%d (%d) {
   ["message":protected]=>
-  string(199) "Error: Class Symfony\Component\Debug\Broken contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (Serializable::serialize, Serializable::unserialize)"
+  string(179) "Error: Class Symfony\Component\Debug\Broken contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (JsonSerializable::jsonSerialize)"
 %a
 }

composer.json

@@ -1,7 +1,7 @@
 {
     "name": "symfony/debug",
     "type": "library",
-    "description": "Symfony Debug Component",
+    "description": "Provides tools to ease debugging PHP code",
     "keywords": [],
     "homepage": "https://symfony.com",
     "license": "MIT",
@@ -16,14 +16,14 @@
         }
     ],
     "require": {
-        "php": "^7.1.3",
-        "psr/log": "~1.0"
+        "php": ">=7.1.3",
+        "psr/log": "^1|^2|^3"
     },
     "conflict": {
         "symfony/http-kernel": "<3.4"
     },
     "require-dev": {
-        "symfony/http-kernel": "~3.4|~4.0"
+        "symfony/http-kernel": "^3.4|^4.0|^5.0"
     },
     "autoload": {
         "psr-4": { "Symfony\\Component\\Debug\\": "" },
@@ -31,10 +31,5 @@
             "/Tests/"
         ]
     },
-    "minimum-stability": "dev",
-    "extra": {
-        "branch-alias": {
-            "dev-master": "4.2-dev"
-        }
-    }
+    "minimum-stability": "dev"
 }

phpunit.xml.dist

@@ -14,10 +14,7 @@
 
     <testsuites>
         <testsuite name="Symfony Debug Component Test Suite">
-            <directory>./Tests/</directory>
-        </testsuite>
-        <testsuite name="Symfony Debug Extension Test Suite">
-            <directory suffix=".phpt">./Resources/ext/tests/</directory>
+            <directory suffix=".phpt">./Tests/</directory>
         </testsuite>
     </testsuites>