Merge branch '3.4' into 4.2

* 3.4:
  minor: the meaning of the data breach was not correct
  Optimize SVGs
  property normalizer should also pass format and context to isAllowedAttribute

DebugClassLoader.php

@@ -11,6 +11,8 @@
 
 namespace Symfony\Component\Debug;
 
+use PHPUnit\Framework\MockObject\Matcher\StatelessInvocation;
+
 /**
  * Autoloader checking if the class is really defined in the file found.
  *
@@ -21,6 +23,7 @@ namespace Symfony\Component\Debug;
  * @author Fabien Potencier <fabien@symfony.com>
  * @author Christophe Coevoet <stof@notk.org>
  * @author Nicolas Grekas <p@tchwork.com>
+ * @author Guilhem Niot <guilhem.niot@gmail.com>
  */
 class DebugClassLoader
 {
@@ -34,6 +37,7 @@ class DebugClassLoader
     private static $deprecated = [];
     private static $internal = [];
     private static $internalMethods = [];
+    private static $annotatedParameters = [];
     private static $darwinCache = ['/' => ['/', []]];
 
     public function __construct(callable $classLoader)
@@ -228,7 +232,7 @@ class DebugClassLoader
         // Detect annotations on the class
         if (false !== $doc = $refl->getDocComment()) {
             foreach (['final', 'deprecated', 'internal'] as $annotation) {
-                if (false !== \strpos($doc, $annotation) && preg_match('#\n\s+\* @'.$annotation.'(?:( .+?)\.?)?\r?\n\s+\*(?: @|/$)#s', $doc, $notice)) {
+                if (false !== \strpos($doc, $annotation) && preg_match('#\n\s+\* @'.$annotation.'(?:( .+?)\.?)?\r?\n\s+\*(?: @|/$|\r?\n)#s', $doc, $notice)) {
                     self::${$annotation}[$class] = isset($notice[1]) ? preg_replace('#\.?\r?\n( \*)? *(?= |\r?\n|$)#', '', $notice[1]) : '';
                 }
             }
@@ -253,7 +257,7 @@ class DebugClassLoader
             if (!isset(self::$checkedClasses[$use])) {
                 $this->checkClass($use);
             }
-            if (isset(self::$deprecated[$use]) && \strncmp($ns, \str_replace('_', '\\', $use), $len)) {
+            if (isset(self::$deprecated[$use]) && \strncmp($ns, \str_replace('_', '\\', $use), $len) && !isset(self::$deprecated[$class])) {
                 $type = class_exists($class, false) ? 'class' : (interface_exists($class, false) ? 'interface' : 'trait');
                 $verb = class_exists($use, false) || interface_exists($class, false) ? 'extends' : (interface_exists($use, false) ? 'implements' : 'uses');
 
@@ -268,11 +272,12 @@ class DebugClassLoader
             return $deprecations;
         }
 
-        // Inherit @final and @internal annotations for methods
+        // Inherit @final, @internal and @param annotations for methods
         self::$finalMethods[$class] = [];
         self::$internalMethods[$class] = [];
+        self::$annotatedParameters[$class] = [];
         foreach ($parentAndOwnInterfaces as $use) {
-            foreach (['finalMethods', 'internalMethods'] as $property) {
+            foreach (['finalMethods', 'internalMethods', 'annotatedParameters'] as $property) {
                 if (isset(self::${$property}[$use])) {
                     self::${$property}[$class] = self::${$property}[$class] ? self::${$property}[$use] + self::${$property}[$class] : self::${$property}[$use];
                 }
@@ -296,15 +301,52 @@ class DebugClassLoader
                 }
             }
 
-            // Detect method annotations
-            if (false === $doc = $method->getDocComment()) {
+            // To read method annotations
+            $doc = $method->getDocComment();
+
+            if (isset(self::$annotatedParameters[$class][$method->name])) {
+                $definedParameters = [];
+                foreach ($method->getParameters() as $parameter) {
+                    $definedParameters[$parameter->name] = true;
+                }
+
+                foreach (self::$annotatedParameters[$class][$method->name] as $parameterName => $deprecation) {
+                    if (!isset($definedParameters[$parameterName]) && !($doc && preg_match("/\\n\\s+\\* @param (.*?)(?<= )\\\${$parameterName}\\b/", $doc))) {
+                        $deprecations[] = sprintf($deprecation, $class);
+                    }
+                }
+            }
+
+            if (!$doc) {
                 continue;
             }
 
+            $finalOrInternal = false;
+
             foreach (['final', 'internal'] as $annotation) {
-                if (false !== \strpos($doc, $annotation) && preg_match('#\n\s+\* @'.$annotation.'(?:( .+?)\.?)?\r?\n\s+\*(?: @|/$)#s', $doc, $notice)) {
+                if (false !== \strpos($doc, $annotation) && preg_match('#\n\s+\* @'.$annotation.'(?:( .+?)\.?)?\r?\n\s+\*(?: @|/$|\r?\n)#s', $doc, $notice)) {
                     $message = isset($notice[1]) ? preg_replace('#\.?\r?\n( \*)? *(?= |\r?\n|$)#', '', $notice[1]) : '';
                     self::${$annotation.'Methods'}[$class][$method->name] = [$class, $message];
+                    $finalOrInternal = true;
+                }
+            }
+
+            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)) {
+                continue;
+            }
+            if (!isset(self::$annotatedParameters[$class][$method->name])) {
+                $definedParameters = [];
+                foreach ($method->getParameters() as $parameter) {
+                    $definedParameters[$parameter->name] = true;
+                }
+            }
+            foreach ($matches as list(, $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);
                 }
             }
         }
@@ -385,6 +427,11 @@ class DebugClassLoader
 
         $dirFiles = self::$darwinCache[$kDir][1];
 
+        if (!isset($dirFiles[$file]) && ') : eval()\'d code' === substr($file, -17)) {
+            // Get the file name from "file_name.php(123) : eval()'d code"
+            $file = substr($file, 0, strrpos($file, '(', -17));
+        }
+
         if (isset($dirFiles[$file])) {
             return $real .= $dirFiles[$file];
         }

ErrorHandler.php

@@ -15,6 +15,7 @@ use Psr\Log\LoggerInterface;
 use Psr\Log\LogLevel;
 use Symfony\Component\Debug\Exception\FatalErrorException;
 use Symfony\Component\Debug\Exception\FatalThrowableError;
+use Symfony\Component\Debug\Exception\FlattenException;
 use Symfony\Component\Debug\Exception\OutOfMemoryException;
 use Symfony\Component\Debug\Exception\SilencedErrorContext;
 use Symfony\Component\Debug\FatalErrorHandler\ClassNotFoundFatalErrorHandler;
@@ -219,7 +220,7 @@ class ErrorHandler
             }
             if (!\is_array($log)) {
                 $log = [$log];
-            } elseif (!array_key_exists(0, $log)) {
+            } elseif (!\array_key_exists(0, $log)) {
                 throw new \InvalidArgumentException('No logger provided');
             }
             if (null === $log[0]) {
@@ -405,15 +406,19 @@ class ErrorHandler
             $context = $e;
         }
 
-        $logMessage = $this->levels[$type].': '.$message;
+        if (false !== strpos($message, "class@anonymous\0")) {
+            $logMessage = $this->levels[$type].': '.(new FlattenException())->setMessage($message)->getMessage();
+        } else {
+            $logMessage = $this->levels[$type].': '.$message;
+        }
 
         if (null !== self::$toStringException) {
             $errorAsException = self::$toStringException;
             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, 3), $type, $file, $line, false) : [];
-                $errorAsException = new SilencedErrorContext($type, $file, $line, $lightTrace);
+                $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;
                 $errorAsException = self::$silencedErrorCache[$id][$message];
@@ -436,7 +441,6 @@ class ErrorHandler
         } else {
             $errorAsException = new \ErrorException($logMessage, 0, $type, $file, $line);
 
-            // Clean the trace by removing function arguments and the first frames added by the error handler itself.
             if ($throw || $this->tracedErrors & $type) {
                 $backtrace = $errorAsException->getTrace();
                 $lightTrace = $this->cleanTrace($backtrace, $type, $file, $line, $throw);
@@ -486,6 +490,11 @@ class ErrorHandler
         if ($this->isRecursive) {
             $log = 0;
         } else {
+            if (!\defined('HHVM_VERSION')) {
+                $currentErrorHandler = set_error_handler('var_dump');
+                restore_error_handler();
+            }
+
             try {
                 $this->isRecursive = true;
                 $level = ($type & $level) ? $this->loggers[$type][1] : LogLevel::DEBUG;
@@ -494,7 +503,7 @@ class ErrorHandler
                 $this->isRecursive = false;
 
                 if (!\defined('HHVM_VERSION')) {
-                    set_error_handler([$this, __FUNCTION__]);
+                    set_error_handler($currentErrorHandler);
                 }
             }
         }
@@ -522,21 +531,24 @@ class ErrorHandler
         $handlerException = null;
 
         if (($this->loggedErrors & $type) || $exception instanceof FatalThrowableError) {
+            if (false !== strpos($message = $exception->getMessage(), "class@anonymous\0")) {
+                $message = (new FlattenException())->setMessage($message)->getMessage();
+            }
             if ($exception instanceof FatalErrorException) {
                 if ($exception instanceof FatalThrowableError) {
                     $error = [
                         'type' => $type,
-                        'message' => $message = $exception->getMessage(),
+                        'message' => $message,
                         'file' => $exception->getFile(),
                         'line' => $exception->getLine(),
                     ];
                 } else {
-                    $message = 'Fatal '.$exception->getMessage();
+                    $message = 'Fatal '.$message;
                 }
             } elseif ($exception instanceof \ErrorException) {
-                $message = 'Uncaught '.$exception->getMessage();
+                $message = 'Uncaught '.$message;
             } else {
-                $message = 'Uncaught Exception: '.$exception->getMessage();
+                $message = 'Uncaught Exception: '.$message;
             }
         }
         if ($this->loggedErrors & $type) {
@@ -665,6 +677,9 @@ 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)
     {
         $lightTrace = $backtrace;
@@ -675,6 +690,13 @@ class ErrorHandler
                 break;
             }
         }
+        if (class_exists(DebugClassLoader::class, false)) {
+            for ($i = \count($lightTrace) - 2; 0 < $i; --$i) {
+                if (DebugClassLoader::class === ($lightTrace[$i]['class'] ?? null)) {
+                    array_splice($lightTrace, --$i, 2);
+                }
+            }
+        }
         if (!($throw || $this->scopedErrors & $type)) {
             for ($i = 0; isset($lightTrace[$i]); ++$i) {
                 unset($lightTrace[$i]['args'], $lightTrace[$i]['object']);

Exception/FlattenException.php

@@ -90,9 +90,14 @@ class FlattenException
         return $this->statusCode;
     }
 
+    /**
+     * @return $this
+     */
     public function setStatusCode($code)
     {
         $this->statusCode = $code;
+
+        return $this;
     }
 
     public function getHeaders()
@@ -100,9 +105,14 @@ class FlattenException
         return $this->headers;
     }
 
+    /**
+     * @return $this
+     */
     public function setHeaders(array $headers)
     {
         $this->headers = $headers;
+
+        return $this;
     }
 
     public function getClass()
@@ -110,9 +120,14 @@ class FlattenException
         return $this->class;
     }
 
+    /**
+     * @return $this
+     */
     public function setClass($class)
     {
-        $this->class = $class;
+        $this->class = 'c' === $class[0] && 0 === strpos($class, "class@anonymous\0") ? get_parent_class($class).'@anonymous' : $class;
+
+        return $this;
     }
 
     public function getFile()
@@ -120,9 +135,14 @@ class FlattenException
         return $this->file;
     }
 
+    /**
+     * @return $this
+     */
     public function setFile($file)
     {
         $this->file = $file;
+
+        return $this;
     }
 
     public function getLine()
@@ -130,9 +150,14 @@ class FlattenException
         return $this->line;
     }
 
+    /**
+     * @return $this
+     */
     public function setLine($line)
     {
         $this->line = $line;
+
+        return $this;
     }
 
     public function getMessage()
@@ -140,9 +165,20 @@ class FlattenException
         return $this->message;
     }
 
+    /**
+     * @return $this
+     */
     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];
+            }, $message);
+        }
+
         $this->message = $message;
+
+        return $this;
     }
 
     public function getCode()
@@ -150,9 +186,14 @@ class FlattenException
         return $this->code;
     }
 
+    /**
+     * @return $this
+     */
     public function setCode($code)
     {
         $this->code = $code;
+
+        return $this;
     }
 
     public function getPrevious()
@@ -160,9 +201,14 @@ class FlattenException
         return $this->previous;
     }
 
+    /**
+     * @return $this
+     */
     public function setPrevious(self $previous)
     {
         $this->previous = $previous;
+
+        return $this;
     }
 
     public function getAllPrevious()
@@ -191,11 +237,14 @@ class FlattenException
         $this->setTraceFromThrowable($exception);
     }
 
-    public function setTraceFromThrowable(\Throwable $throwable): void
+    public function setTraceFromThrowable(\Throwable $throwable)
     {
-        $this->setTrace($throwable->getTrace(), $throwable->getFile(), $throwable->getLine());
+        return $this->setTrace($throwable->getTrace(), $throwable->getFile(), $throwable->getLine());
     }
 
+    /**
+     * @return $this
+     */
     public function setTrace($trace, $file, $line)
     {
         $this->trace = [];
@@ -229,6 +278,8 @@ class FlattenException
                 'args' => isset($entry['args']) ? $this->flattenArgs($entry['args']) : [],
             ];
         }
+
+        return $this;
     }
 
     private function flattenArgs($args, $level = 0, &$count = 0)

Tests/DebugClassLoaderTest.php

@@ -44,7 +44,7 @@ class DebugClassLoaderTest extends TestCase
 
         $functions = spl_autoload_functions();
         foreach ($functions as $function) {
-            if (is_array($function) && $function[0] instanceof DebugClassLoader) {
+            if (\is_array($function) && $function[0] instanceof DebugClassLoader) {
                 $reflClass = new \ReflectionClass($function[0]);
                 $reflProp = $reflClass->getProperty('classLoader');
                 $reflProp->setAccessible(true);
@@ -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 = __NAMESPACE__.'\\Fixtures\\FinalClass'.$i++, false)) {
             spl_autoload_call($finalClass);
             class_exists('Test\\'.__NAMESPACE__.'\\Extends'.substr($finalClass, strrpos($finalClass, '\\') + 1), true);
         }
@@ -280,6 +280,24 @@ class DebugClassLoaderTest extends TestCase
         ]);
     }
 
+    public function testExtendedMethodDefinesNewParameters()
+    {
+        $deprecations = [];
+        set_error_handler(function ($type, $msg) use (&$deprecations) { $deprecations[] = $msg; });
+        $e = error_reporting(E_USER_DEPRECATED);
+
+        class_exists(__NAMESPACE__.'\\Fixtures\SubClassWithAnnotatedParameters', 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::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);
+    }
+
     public function testUseTraitWithInternalMethod()
     {
         $deprecations = [];
@@ -293,6 +311,11 @@ class DebugClassLoaderTest extends TestCase
 
         $this->assertSame([], $deprecations);
     }
+
+    public function testEvaluatedCode()
+    {
+        $this->assertTrue(class_exists(__NAMESPACE__.'\Fixtures\DefinitionInEvaluatedCode', true));
+    }
 }
 
 class ClassLoader
@@ -308,7 +331,7 @@ class ClassLoader
 
     public function findFile($class)
     {
-        $fixtureDir = __DIR__.DIRECTORY_SEPARATOR.'Fixtures'.DIRECTORY_SEPARATOR;
+        $fixtureDir = __DIR__.\DIRECTORY_SEPARATOR.'Fixtures'.\DIRECTORY_SEPARATOR;
 
         if (__NAMESPACE__.'\TestingUnsilencing' === $class) {
             eval('-- parse error --');
@@ -317,7 +340,7 @@ class ClassLoader
         } elseif (__NAMESPACE__.'\TestingCaseMismatch' === $class) {
             eval('namespace '.__NAMESPACE__.'; class TestingCaseMisMatch {}');
         } elseif (__NAMESPACE__.'\Fixtures\Psr4CaseMismatch' === $class) {
-            return $fixtureDir.'psr4'.DIRECTORY_SEPARATOR.'Psr4CaseMismatch.php';
+            return $fixtureDir.'psr4'.\DIRECTORY_SEPARATOR.'Psr4CaseMismatch.php';
         } elseif (__NAMESPACE__.'\Fixtures\NotPSR0' === $class) {
             return $fixtureDir.'reallyNotPsr0.php';
         } elseif (__NAMESPACE__.'\Fixtures\NotPSR0bis' === $class) {

Tests/ErrorHandlerTest.php

@@ -12,12 +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\SilencedErrorContext;
+use Symfony\Component\Debug\Tests\Fixtures\ErrorHandlerThatUsesThePreviousOne;
 use Symfony\Component\Debug\Tests\Fixtures\LoggerThatSetAnErrorHandler;
 
 /**
@@ -481,7 +481,7 @@ class ErrorHandlerTest extends TestCase
 
     public function testHandleErrorException()
     {
-        $exception = new \Error("Class 'Foo' not found");
+        $exception = new \Error("Class 'IReallyReallyDoNotExistAnywhereInTheRepositoryISwear' not found");
 
         $handler = new ErrorHandler();
         $handler->setExceptionHandler(function () use (&$args) {
@@ -491,7 +491,7 @@ class ErrorHandlerTest extends TestCase
         $handler->handleException($exception);
 
         $this->assertInstanceOf('Symfony\Component\Debug\Exception\ClassNotFoundException', $args[0]);
-        $this->assertStringStartsWith("Attempted to load class \"Foo\" from the global namespace.\nDid you forget a \"use\" statement", $args[0]->getMessage());
+        $this->assertStringStartsWith("Attempted to load class \"IReallyReallyDoNotExistAnywhereInTheRepositoryISwear\" from the global namespace.\nDid you forget a \"use\" statement", $args[0]->getMessage());
     }
 
     /**
@@ -508,26 +508,40 @@ class ErrorHandlerTest extends TestCase
     }
 
     /**
-     * @dataProvider errorHandlerIsNotLostWhenLoggingProvider
+     * @dataProvider errorHandlerWhenLoggingProvider
      */
-    public function testErrorHandlerIsNotLostWhenLogging($customErrorHandlerHasBeenPreviouslyDefined, LoggerInterface $logger)
+    public function testErrorHandlerWhenLogging($previousHandlerWasDefined, $loggerSetsAnotherHandler, $nextHandlerIsDefined)
     {
         try {
-            if ($customErrorHandlerHasBeenPreviouslyDefined) {
+            if ($previousHandlerWasDefined) {
                 set_error_handler('count');
             }
 
+            $logger = $loggerSetsAnotherHandler ? new LoggerThatSetAnErrorHandler() : new NullLogger();
+
             $handler = ErrorHandler::register();
             $handler->setDefaultLogger($logger);
 
+            if ($nextHandlerIsDefined) {
+                $handler = ErrorHandlerThatUsesThePreviousOne::register();
+            }
+
             @trigger_error('foo', E_USER_DEPRECATED);
             @trigger_error('bar', E_USER_DEPRECATED);
 
             $this->assertSame([$handler, 'handleError'], set_error_handler('var_dump'));
 
+            if ($logger instanceof LoggerThatSetAnErrorHandler) {
+                $this->assertCount(2, $logger->cleanLogs());
+            }
+
             restore_error_handler();
 
-            if ($customErrorHandlerHasBeenPreviouslyDefined) {
+            if ($previousHandlerWasDefined) {
+                restore_error_handler();
+            }
+
+            if ($nextHandlerIsDefined) {
                 restore_error_handler();
             }
         } finally {
@@ -536,13 +550,14 @@ class ErrorHandlerTest extends TestCase
         }
     }
 
-    public function errorHandlerIsNotLostWhenLoggingProvider()
+    public function errorHandlerWhenLoggingProvider()
     {
-        return [
-            [false, new NullLogger()],
-            [true, new NullLogger()],
-            [false, new LoggerThatSetAnErrorHandler()],
-            [true, new LoggerThatSetAnErrorHandler()],
-        ];
+        foreach ([false, true] as $previousHandlerWasDefined) {
+            foreach ([false, true] as $loggerSetsAnotherHandler) {
+                foreach ([false, true] as $nextHandlerIsDefined) {
+                    yield [$previousHandlerWasDefined, $loggerSetsAnotherHandler, $nextHandlerIsDefined];
+                }
+            }
+        }
     }
 }

Tests/Exception/FlattenExceptionTest.php

@@ -333,6 +333,19 @@ class FlattenExceptionTest extends TestCase
         $this->assertNotContains('*value1*', $serializeTrace);
     }
 
+    public function testAnonymousClass()
+    {
+        $flattened = FlattenException::create(new class() extends \RuntimeException {
+        });
+
+        $this->assertSame('RuntimeException@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());
+    }
+
     private function createException($foo)
     {
         return new \Exception();

Tests/Fixtures/ClassWithAnnotatedParameters.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class ClassWithAnnotatedParameters
+{
+    /**
+     * @param string $foo this is a foo parameter
+     */
+    public function fooMethod(string $foo)
+    {
+    }
+
+    /**
+     * @param string $bar parameter not implemented yet
+     */
+    public function barMethod(/* string $bar = null */)
+    {
+    }
+
+    /**
+     * @param Quz $quz parameter not implemented yet
+     */
+    public function quzMethod(/* Quz $quz = null */)
+    {
+    }
+
+    /**
+     * @param true $yes
+     */
+    public function isSymfony()
+    {
+    }
+}

Tests/Fixtures/DefinitionInEvaluatedCode.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+eval('
+    namespace Symfony\Component\Debug\Tests\Fixtures;
+
+    class DefinitionInEvaluatedCode
+    {
+    }
+');

Tests/Fixtures/ErrorHandlerThatUsesThePreviousOne.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class ErrorHandlerThatUsesThePreviousOne
+{
+    private static $previous;
+
+    public static function register()
+    {
+        $handler = new static();
+
+        self::$previous = set_error_handler([$handler, 'handleError']);
+
+        return $handler;
+    }
+
+    public function handleError($type, $message, $file, $line, $context)
+    {
+        return \call_user_func(self::$previous, $type, $message, $file, $line, $context);
+    }
+}

Tests/Fixtures/FinalClasses.php

@@ -30,6 +30,7 @@ class FinalClass3
 
 /**
  * @final
+ *
  * @author John Doe
  */
 class FinalClass4
@@ -63,7 +64,6 @@ class FinalClass6
  * @author John Doe
  *
  * @final another
- *
  *        multiline comment...
  *
  * @return string
@@ -76,6 +76,7 @@ class FinalClass7
 /**
  * @author John Doe
  * @final
+ *
  * @return string
  */
 class FinalClass8

Tests/Fixtures/FinalMethod.php

@@ -13,6 +13,8 @@ class FinalMethod
 
     /**
      * @final
+     *
+     * @return int
      */
     public function finalMethod2()
     {

Tests/Fixtures/InterfaceWithAnnotatedParameters.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * Ensures a deprecation is triggered when a new parameter is not declared in child classes.
+ */
+interface InterfaceWithAnnotatedParameters
+{
+    /**
+     * @param bool $matrix
+     */
+    public function whereAmI();
+}

Tests/Fixtures/LoggerThatSetAnErrorHandler.php

@@ -2,13 +2,14 @@
 
 namespace Symfony\Component\Debug\Tests\Fixtures;
 
-use Psr\Log\AbstractLogger;
+use Symfony\Component\Debug\BufferingLogger;
 
-class LoggerThatSetAnErrorHandler extends AbstractLogger
+class LoggerThatSetAnErrorHandler extends BufferingLogger
 {
     public function log($level, $message, array $context = [])
     {
         set_error_handler('is_string');
+        parent::log($level, $message, $context);
         restore_error_handler();
     }
 }

Tests/Fixtures/SubClassWithAnnotatedParameters.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class SubClassWithAnnotatedParameters extends ClassWithAnnotatedParameters implements InterfaceWithAnnotatedParameters
+{
+    use TraitWithAnnotatedParameters;
+
+    public function fooMethod(string $foo)
+    {
+    }
+
+    public function barMethod($bar = null)
+    {
+    }
+
+    public function quzMethod()
+    {
+    }
+
+    public function whereAmI()
+    {
+    }
+}

Tests/Fixtures/TraitWithAnnotatedParameters.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+trait TraitWithAnnotatedParameters
+{
+    /**
+     * `@param` annotations in traits are not parsed.
+     */
+    public function isSymfony()
+    {
+    }
+}

composer.json

@@ -34,7 +34,7 @@
     "minimum-stability": "dev",
     "extra": {
         "branch-alias": {
-            "dev-master": "4.1-dev"
+            "dev-master": "4.2-dev"
         }
     }
 }