Merge branch '4.1' into 4.2

* 4.1:
  [HttpFoundation] Check file exists before unlink
  [Console] Fixed #29835: ConfirmationQuestion with default true for answer '0'
  [Translation] Concatenated translation messages
  [Form] ensure compatibility with older PHPUnit mocks
  [Serializer] Docblock about throwing exceptions on serializer
  [Debug][ErrorHandler] Preserve our error handler when a logger set another one
  [Form] Changed UrlType input type to text when default_protocol is not null
  [Bugfix] MemcachedSessionHandler::close() must close connection

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)
@@ -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)) {
                     $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);
                 }
             }
         }

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;
@@ -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);
@@ -522,21 +526,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 +672,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 +685,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)

ExceptionHandler.php

@@ -253,7 +253,8 @@ EOF
         } catch (\Exception $e) {
             // something nasty happened and we cannot throw an exception anymore
             if ($this->debug) {
-                $title = sprintf('Exception thrown when handling an exception (%s: %s)', \get_class($e), $this->escapeHtml($e->getMessage()));
+                $e = FlattenException::create($e);
+                $title = sprintf('Exception thrown when handling an exception (%s: %s)', $e->getClass(), $this->escapeHtml($e->getMessage()));
             } else {
                 $title = 'Whoops, looks like something went wrong.';
             }

Tests/DebugClassLoaderTest.php

@@ -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 = [];

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/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/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"
         }
     }
 }