symfony
diff --git a/‎src/Symfony/Component/OptionsResolver/CHANGELOG.md
Copy file name to clipboardExpand all lines: src/Symfony/Component/OptionsResolver/CHANGELOG.md
+5Lines changed: 5 additions & 0 deletions b/‎src/Symfony/Component/OptionsResolver/CHANGELOG.md
Copy file name to clipboardExpand all lines: src/Symfony/Component/OptionsResolver/CHANGELOG.md
+5Lines changed: 5 additions & 0 deletions
diff --git a/‎src/Symfony/Component/OptionsResolver/OptionsResolver.php
Copy file name to clipboardExpand all lines: src/Symfony/Component/OptionsResolver/OptionsResolver.php
+54-4Lines changed: 54 additions & 4 deletions b/‎src/Symfony/Component/OptionsResolver/OptionsResolver.php
Copy file name to clipboardExpand all lines: src/Symfony/Component/OptionsResolver/OptionsResolver.php
+54-4Lines changed: 54 additions & 4 deletions
@@ -1,6 +1,11 @@
 CHANGELOG
 =========
 
+4.2.0
+-----
+
+ * added support for nesting options as default value
+
 3.4.0
 -----
 
 
@@ -36,6 +36,13 @@ class OptionsResolver implements Options
      */
     private $defaults = array();
 
+    /**
+     * A list of closures for nested options.
+     *
+     * @var \Closure[][]
+     */
+    private $nested = array();
+
     /**
      * The names of required options.
      */
@@ -161,15 +168,27 @@ public function setDefault($option, $value)
                 $this->lazy[$option][] = $value;
                 $this->defined[$option] = true;
 
-                // Make sure the option is processed
-                unset($this->resolved[$option]);
+                // Make sure the option is processed and is not nested anymore
+                unset($this->resolved[$option], $this->nested[$option]);
+
+                return $this;
+            }
+
+            if (isset($params[0]) && null !== ($class = $params[0]->getClass()) && self::class === $class->name && (!isset($params[1]) || (null !== ($class = $params[1]->getClass()) && Options::class === $class->name))) {
+                $this->nested[$option][] = $value;
+
+                $this->defaults[$option] = array();
+                $this->defined[$option] = true;
+
+                // Make sure the option is processed and this option is not lazy anymore
+                unset($this->resolved[$option], $this->lazy[$option]);
 
                 return $this;
             }
         }
 
-        // This option is not lazy anymore
-        unset($this->lazy[$option]);
+        // This option is not lazy nor nested anymore
+        unset($this->lazy[$option], $this->nested[$option]);
 
         // Yet undefined options can be marked as resolved, because we only need
         // to resolve options with lazy closures, normalizers or validation
@@ -614,6 +633,7 @@ public function clear()
 
         $this->defined = array();
         $this->defaults = array();
+        $this->nested = array();
         $this->required = array();
         $this->resolved = array();
         $this->lazy = array();
@@ -745,6 +765,36 @@ public function offsetGet($option)
 
         $value = $this->defaults[$option];
 
+        // Resolve the option if the default value is nested
+        if (isset($this->nested[$option])) {
+            // If the closure is already being called, we have a cyclic
+            // dependency
+            if (isset($this->calling[$option])) {
+                throw new OptionDefinitionException(sprintf('The options "%s" have a cyclic dependency.', implode('", "', array_keys($this->calling))));
+            }
+
+            // Nested values must be an array
+            if (!\is_array($value)) {
+                throw new InvalidOptionsException(sprintf('The nested option "%s" with value %s is expected to be of type array, but is of type "%s".', $option, $this->formatValue($value), $this->formatTypeOf($value, 'array')));
+            }
+
+            // The following section must be protected from cyclic
+            // calls. Set $calling for the current $option to detect a cyclic
+            // dependency
+            // BEGIN
+            $this->calling[$option] = true;
+            try {
+                $resolver = new self();
+                foreach ($this->nested[$option] as $closure) {
+                    $closure($resolver, $this);
+                }
+                $value = $resolver->resolve($value);
+            } finally {
+                unset($this->calling[$option]);
+            }
+            // END
+        }
+
         // Resolve the option if the default value is lazily evaluated
         if (isset($this->lazy[$option])) {
             // If the closure is already being called, we have a cyclic