Merge branch '3.4' into 4.0

* 3.4:
  [Console] fix CS
  [OptionResolver] resolve arrays
  [TwigBridge] Fix missing path and separators in loader paths list on debug:twig output
  [PropertyInfo] Fix dock block lookup fallback loop
  [HttpFoundation] don't encode cookie name for BC
  improve deprecation messages
  minor #27858 [Console] changed warning verbosity; fixes typo (adrian-enspired)
  AppBundle->App.
  [DI] Fix dumping ignore-on-uninitialized references to synthetic services

Author: nicolas-grekas

OptionsResolver.php

@@ -433,7 +433,7 @@ public function setAllowedValues($option, $allowedValues)
             ));
         }
 
-        $this->allowedValues[$option] = is_array($allowedValues) ? $allowedValues : array($allowedValues);
+        $this->allowedValues[$option] = \is_array($allowedValues) ? $allowedValues : array($allowedValues);
 
         // Make sure the option is processed
         unset($this->resolved[$option]);
@@ -785,14 +785,13 @@ public function offsetGet($option)
             }
 
             if (!$valid) {
-                throw new InvalidOptionsException(sprintf(
-                    'The option "%s" with value %s is expected to be of type '.
-                    '"%s", but is of type "%s".',
-                    $option,
-                    $this->formatValue($value),
-                    implode('" or "', $this->allowedTypes[$option]),
-                    implode('|', array_keys($invalidTypes))
-                ));
+                $keys = array_keys($invalidTypes);
+
+                if (1 === \count($keys) && '[]' === substr($keys[0], -2)) {
+                    throw new InvalidOptionsException(sprintf('The option "%s" with value %s is expected to be of type "%s", but one of the elements is of type "%s".', $option, $this->formatValue($value), implode('" or "', $this->allowedTypes[$option]), $keys[0]));
+                }
+
+                throw new InvalidOptionsException(sprintf('The option "%s" with value %s is expected to be of type "%s", but is of type "%s".', $option, $this->formatValue($value), implode('" or "', $this->allowedTypes[$option]), implode('|', array_keys($invalidTypes))));
             }
         }
 
@@ -868,32 +867,10 @@ public function offsetGet($option)
         return $value;
     }
 
-    /**
-     * @param string $type
-     * @param mixed  $value
-     * @param array  &$invalidTypes
-     *
-     * @return bool
-     */
-    private function verifyTypes($type, $value, array &$invalidTypes)
+    private function verifyTypes(string $type, $value, array &$invalidTypes): bool
     {
-        if ('[]' === substr($type, -2) && is_array($value)) {
-            $originalType = $type;
-            $type = substr($type, 0, -2);
-            $invalidValues = array_filter( // Filter out valid values, keeping invalid values in the resulting array
-                $value,
-                function ($value) use ($type) {
-                    return !self::isValueValidType($type, $value);
-                }
-            );
-
-            if (!$invalidValues) {
-                return true;
-            }
-
-            $invalidTypes[$this->formatTypeOf($value, $originalType)] = true;
-
-            return false;
+        if (\is_array($value) && '[]' === substr($type, -2)) {
+            return $this->verifyArrayType($type, $value, $invalidTypes);
         }
 
         if (self::isValueValidType($type, $value)) {
@@ -907,6 +884,43 @@ function ($value) use ($type) {
         return false;
     }
 
+    private function verifyArrayType(string $type, array $value, array &$invalidTypes, int $level = 0): bool
+    {
+        $type = substr($type, 0, -2);
+
+        $suffix = '[]';
+        while (\strlen($suffix) <= $level * 2) {
+            $suffix .= '[]';
+        }
+
+        if ('[]' === substr($type, -2)) {
+            $success = true;
+            foreach ($value as $item) {
+                if (!\is_array($item)) {
+                    $invalidTypes[$this->formatTypeOf($item, null).$suffix] = true;
+
+                    return false;
+                }
+
+                if (!$this->verifyArrayType($type, $item, $invalidTypes, $level + 1)) {
+                    $success = false;
+                }
+            }
+
+            return $success;
+        }
+
+        foreach ($value as $item) {
+            if (!self::isValueValidType($type, $item)) {
+                $invalidTypes[$this->formatTypeOf($item, $type).$suffix] = $value;
+
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Returns whether a resolved option with the given name exists.
      *
@@ -987,13 +1001,13 @@ private function formatTypeOf($value, ?string $type): string
             while ('[]' === substr($type, -2)) {
                 $type = substr($type, 0, -2);
                 $value = array_shift($value);
-                if (!is_array($value)) {
+                if (!\is_array($value)) {
                     break;
                 }
                 $suffix .= '[]';
             }
 
-            if (is_array($value)) {
+            if (\is_array($value)) {
                 $subTypes = array();
                 foreach ($value as $val) {
                     $subTypes[$this->formatTypeOf($val, null)] = true;
@@ -1003,7 +1017,7 @@ private function formatTypeOf($value, ?string $type): string
             }
         }
 
-        return (is_object($value) ? get_class($value) : gettype($value)).$suffix;
+        return (\is_object($value) ? get_class($value) : gettype($value)).$suffix;
     }
 
     /**
@@ -1017,19 +1031,19 @@ private function formatTypeOf($value, ?string $type): string
      */
     private function formatValue($value): string
     {
-        if (is_object($value)) {
+        if (\is_object($value)) {
             return get_class($value);
         }
 
-        if (is_array($value)) {
+        if (\is_array($value)) {
             return 'array';
         }
 
-        if (is_string($value)) {
+        if (\is_string($value)) {
             return '"'.$value.'"';
         }
 
-        if (is_resource($value)) {
+        if (\is_resource($value)) {
             return 'resource';
         }
 
@@ -1065,8 +1079,21 @@ private function formatValues(array $values): string
         return implode(', ', $values);
     }
 
-    private static function isValueValidType($type, $value)
+    private static function isValueValidType(string $type, $value): bool
     {
         return (function_exists($isFunction = 'is_'.$type) && $isFunction($value)) || $value instanceof $type;
     }
+
+    private function getInvalidValues(array $arrayValues, string $type): array
+    {
+        $invalidValues = array();
+
+        foreach ($arrayValues as $key => $value) {
+            if (!self::isValueValidType($type, $value)) {
+                $invalidValues[$key] = $value;
+            }
+        }
+
+        return $invalidValues;
+    }
 }

Tests/OptionsResolverTest.php

@@ -483,7 +483,7 @@ public function testFailIfSetAllowedTypesFromLazyOption()
 
     /**
      * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
-     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "int[]", but is of type "DateTime[]".
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "int[]", but one of the elements is of type "DateTime[]".
      */
     public function testResolveFailsIfInvalidTypedArray()
     {
@@ -507,7 +507,7 @@ public function testResolveFailsWithNonArray()
 
     /**
      * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
-     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "int[]", but is of type "integer|stdClass|array|DateTime[]".
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "int[]", but one of the elements is of type "stdClass[]".
      */
     public function testResolveFailsIfTypedArrayContainsInvalidTypes()
     {
@@ -524,7 +524,7 @@ public function testResolveFailsIfTypedArrayContainsInvalidTypes()
 
     /**
      * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
-     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "int[][]", but is of type "double[][]".
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "int[][]", but one of the elements is of type "double[][]".
      */
     public function testResolveFailsWithCorrectLevelsButWrongScalar()
     {
@@ -1586,4 +1586,151 @@ public function testCountFailsOutsideResolve()
 
         count($this->resolver);
     }
+
+    public function testNestedArrays()
+    {
+        $this->resolver->setDefined('foo');
+        $this->resolver->setAllowedTypes('foo', 'int[][]');
+
+        $this->assertEquals(array(
+            'foo' => array(
+                array(
+                    1, 2,
+                ),
+            ),
+        ), $this->resolver->resolve(
+            array(
+                'foo' => array(
+                    array(1, 2),
+                ),
+            )
+        ));
+    }
+
+    public function testNested2Arrays()
+    {
+        $this->resolver->setDefined('foo');
+        $this->resolver->setAllowedTypes('foo', 'int[][][][]');
+
+        $this->assertEquals(array(
+            'foo' => array(
+                array(
+                    array(
+                        array(
+                            1, 2,
+                        ),
+                    ),
+                ),
+            ),
+        ), $this->resolver->resolve(
+            array(
+                'foo' => array(
+                    array(
+                        array(
+                            array(1, 2),
+                        ),
+                    ),
+                ),
+            )
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "float[][][][]", but one of the elements is of type "integer[][][][]".
+     */
+    public function testNestedArraysException()
+    {
+        $this->resolver->setDefined('foo');
+        $this->resolver->setAllowedTypes('foo', 'float[][][][]');
+
+        $this->resolver->resolve(
+            array(
+                'foo' => array(
+                    array(
+                        array(
+                            array(1, 2),
+                        ),
+                    ),
+                ),
+            )
+        );
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "int[][]", but one of the elements is of type "boolean[][]".
+     */
+    public function testNestedArrayException1()
+    {
+        $this->resolver->setDefined('foo');
+        $this->resolver->setAllowedTypes('foo', 'int[][]');
+        $this->resolver->resolve(array(
+            'foo' => array(
+                array(1, true, 'str', array(2, 3)),
+            ),
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "int[][]", but one of the elements is of type "boolean[][]".
+     */
+    public function testNestedArrayException2()
+    {
+        $this->resolver->setDefined('foo');
+        $this->resolver->setAllowedTypes('foo', 'int[][]');
+        $this->resolver->resolve(array(
+            'foo' => array(
+                array(true, 'str', array(2, 3)),
+            ),
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "string[][][]", but one of the elements is of type "string[][]".
+     */
+    public function testNestedArrayException3()
+    {
+        $this->resolver->setDefined('foo');
+        $this->resolver->setAllowedTypes('foo', 'string[][][]');
+        $this->resolver->resolve(array(
+            'foo' => array(
+                array('str', array(1, 2)),
+            ),
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "string[][][]", but one of the elements is of type "integer[][][]".
+     */
+    public function testNestedArrayException4()
+    {
+        $this->resolver->setDefined('foo');
+        $this->resolver->setAllowedTypes('foo', 'string[][][]');
+        $this->resolver->resolve(array(
+            'foo' => array(
+                array(
+                    array('str'), array(1, 2), ),
+            ),
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     * @expectedExceptionMessage The option "foo" with value array is expected to be of type "string[]", but one of the elements is of type "array[]".
+     */
+    public function testNestedArrayException5()
+    {
+        $this->resolver->setDefined('foo');
+        $this->resolver->setAllowedTypes('foo', 'string[]');
+        $this->resolver->resolve(array(
+            'foo' => array(
+                array(
+                    array('str'), array(1, 2), ),
+            ),
+        ));
+    }
 }