vendor/symfony/config/Builder/ConfigBuilderGenerator.php line 55

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Config\Builder;
  14. use Symfony\Component\Config\Definition\ArrayNode;
  15. use Symfony\Component\Config\Definition\BaseNode;
  16. use Symfony\Component\Config\Definition\BooleanNode;
  17. use Symfony\Component\Config\Definition\Builder\ExprBuilder;
  18. use Symfony\Component\Config\Definition\ConfigurationInterface;
  19. use Symfony\Component\Config\Definition\EnumNode;
  20. use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
  21. use Symfony\Component\Config\Definition\FloatNode;
  22. use Symfony\Component\Config\Definition\IntegerNode;
  23. use Symfony\Component\Config\Definition\NodeInterface;
  24. use Symfony\Component\Config\Definition\PrototypedArrayNode;
  25. use Symfony\Component\Config\Definition\ScalarNode;
  26. use Symfony\Component\Config\Definition\VariableNode;
  27. use Symfony\Component\Config\Loader\ParamConfigurator;
  29. /**
  30.  * Generate ConfigBuilders to help create valid config.
  31.  *
  32.  * @author Tobias Nyholm <tobias.nyholm@gmail.com>
  33.  */
  34. class ConfigBuilderGenerator implements ConfigBuilderGeneratorInterface
  35. {
  36.     /**
  37.      * @var ClassBuilder[]
  38.      */
  39.     private array $classes = [];
  40.     private string $outputDir;
  42.     public function __construct(string $outputDir)
  43.     {
  44.         $this->outputDir = $outputDir;
  45.     }
  47.     /**
  48.      * @return \Closure that will return the root config class
  49.      */
  50.     public function build(ConfigurationInterface $configuration): \Closure
  51.     {
  52.         $this->classes = [];
  54.         $rootNode = $configuration->getConfigTreeBuilder()->buildTree();
  55.         $rootClass = new ClassBuilder('Symfony\\Config', $rootNode->getName());
  57.         $path = $this->getFullPath($rootClass);
  58.         if (!is_file($path)) {
  59.             // Generate the class if the file not exists
  60.             $this->classes[] = $rootClass;
  61.             $this->buildNode($rootNode, $rootClass, $this->getSubNamespace($rootClass));
  62.             $rootClass->addImplements(ConfigBuilderInterface::class);
  63.             $rootClass->addMethod('getExtensionAlias', '
  64. public function NAME(): string
  65. {
  66.     return \'ALIAS\';
  67. }', ['ALIAS' => $rootNode->getPath()]);
  69.             $this->writeClasses();
  70.         }
  72.         return function () use ($path, $rootClass) {
  73.             require_once $path;
  74.             $className = $rootClass->getFqcn();
  76.             return new $className();
  77.         };
  78.     }
  80.     private function getFullPath(ClassBuilder $class): string
  81.     {
  82.         $directory = $this->outputDir.\DIRECTORY_SEPARATOR.$class->getDirectory();
  83.         if (!is_dir($directory)) {
  84.             @mkdir($directory, 0777, true);
  85.         }
  87.         return $directory.\DIRECTORY_SEPARATOR.$class->getFilename();
  88.     }
  90.     private function writeClasses(): void
  91.     {
  92.         foreach ($this->classes as $class) {
  93.             $this->buildConstructor($class);
  94.             $this->buildToArray($class);
  95.             if ($class->getProperties()) {
  96.                 $class->addProperty('_usedProperties', null, '[]');
  97.             }
  98.             $this->buildSetExtraKey($class);
  100.             file_put_contents($this->getFullPath($class), $class->build());
  101.         }
  103.         $this->classes = [];
  104.     }
  106.     private function buildNode(NodeInterface $node, ClassBuilder $class, string $namespace): void
  107.     {
  108.         if (!$node instanceof ArrayNode) {
  109.             throw new \LogicException('The node was expected to be an ArrayNode. This Configuration includes an edge case not supported yet.');
  110.         }
  112.         foreach ($node->getChildren() as $child) {
  113.             match (true) {
  114.                 $child instanceof ScalarNode => $this->handleScalarNode($child, $class),
  115.                 $child instanceof PrototypedArrayNode => $this->handlePrototypedArrayNode($child, $class, $namespace),
  116.                 $child instanceof VariableNode => $this->handleVariableNode($child, $class),
  117.                 $child instanceof ArrayNode => $this->handleArrayNode($child, $class, $namespace),
  118.                 default => throw new \RuntimeException(sprintf('Unknown node "%s".', $child::class)),
  119.             };
  120.         }
  121.     }
  123.     private function handleArrayNode(ArrayNode $node, ClassBuilder $class, string $namespace): void
  124.     {
  125.         $childClass = new ClassBuilder($namespace, $node->getName());
  126.         $childClass->setAllowExtraKeys($node->shouldIgnoreExtraKeys());
  127.         $class->addRequire($childClass);
  128.         $this->classes[] = $childClass;
  130.         $hasNormalizationClosures = $this->hasNormalizationClosures($node);
  131.         $comment = $this->getComment($node);
  132.         if ($hasNormalizationClosures) {
  133.             $comment = sprintf(" * @template TValue\n * @param TValue \$value\n%s", $comment);
  134.             $comment .= sprintf(' * @return %s|$this'."\n", $childClass->getFqcn());
  135.             $comment .= sprintf(' * @psalm-return (TValue is array ? %s : static)'."\n ", $childClass->getFqcn());
  136.         }
  137.         if ('' !== $comment) {
  138.             $comment = "/**\n$comment*/\n";
  139.         }
  141.         $property = $class->addProperty(
  142.             $node->getName(),
  143.             $this->getType($childClass->getFqcn(), $hasNormalizationClosures)
  144.         );
  145.         $nodeTypes = $this->getParameterTypes($node);
  146.         $body = $hasNormalizationClosures ? '
  147. COMMENTpublic function NAME(PARAM_TYPE $value = []): CLASS|static
  148. {
  149.     if (!\is_array($value)) {
  150.         $this->_usedProperties[\'PROPERTY\'] = true;
  151.         $this->PROPERTY = $value;
  153.         return $this;
  154.     }
  156.     if (!$this->PROPERTY instanceof CLASS) {
  157.         $this->_usedProperties[\'PROPERTY\'] = true;
  158.         $this->PROPERTY = new CLASS($value);
  159.     } elseif (0 < \func_num_args()) {
  160.         throw new InvalidConfigurationException(\'The node created by "NAME()" has already been initialized. You cannot pass values the second time you call NAME().\');
  161.     }
  163.     return $this->PROPERTY;
  164. }' : '
  165. COMMENTpublic function NAME(array $value = []): CLASS
  166. {
  167.     if (null === $this->PROPERTY) {
  168.         $this->_usedProperties[\'PROPERTY\'] = true;
  169.         $this->PROPERTY = new CLASS($value);
  170.     } elseif (0 < \func_num_args()) {
  171.         throw new InvalidConfigurationException(\'The node created by "NAME()" has already been initialized. You cannot pass values the second time you call NAME().\');
  172.     }
  174.     return $this->PROPERTY;
  175. }';
  176.         $class->addUse(InvalidConfigurationException::class);
  177.         $class->addMethod($node->getName(), $body, [
  178.             'COMMENT' => $comment,
  179.             'PROPERTY' => $property->getName(),
  180.             'CLASS' => $childClass->getFqcn(),
  181.             'PARAM_TYPE' => \in_array('mixed', $nodeTypes, true) ? 'mixed' : implode('|', $nodeTypes),
  182.         ]);
  184.         $this->buildNode($node, $childClass, $this->getSubNamespace($childClass));
  185.     }
  187.     private function handleVariableNode(VariableNode $node, ClassBuilder $class): void
  188.     {
  189.         $comment = $this->getComment($node);
  190.         $property = $class->addProperty($node->getName());
  191.         $class->addUse(ParamConfigurator::class);
  193.         $body = '
  194. /**
  195. COMMENT *
  196.  * @return $this
  197.  */
  198. public function NAME(mixed $valueDEFAULT): static
  199. {
  200.     $this->_usedProperties[\'PROPERTY\'] = true;
  201.     $this->PROPERTY = $value;
  203.     return $this;
  204. }';
  205.         $class->addMethod($node->getName(), $body, [
  206.             'PROPERTY' => $property->getName(),
  207.             'COMMENT' => $comment,
  208.             'DEFAULT' => $node->hasDefaultValue() ? ' = '.var_export($node->getDefaultValue(), true) : '',
  209.         ]);
  210.     }
  212.     private function handlePrototypedArrayNode(PrototypedArrayNode $node, ClassBuilder $class, string $namespace): void
  213.     {
  214.         $name = $this->getSingularName($node);
  215.         $prototype = $node->getPrototype();
  216.         $methodName = $name;
  217.         $hasNormalizationClosures = $this->hasNormalizationClosures($node) || $this->hasNormalizationClosures($prototype);
  219.         $nodeParameterTypes = $this->getParameterTypes($node);
  220.         $prototypeParameterTypes = $this->getParameterTypes($prototype);
  221.         if (!$prototype instanceof ArrayNode || ($prototype instanceof PrototypedArrayNode && $prototype->getPrototype() instanceof ScalarNode)) {
  222.             $class->addUse(ParamConfigurator::class);
  223.             $property = $class->addProperty($node->getName());
  224.             if (null === $key = $node->getKeyAttribute()) {
  225.                 // This is an array of values; don't use singular name
  226.                 $nodeTypesWithoutArray = array_filter($nodeParameterTypes, static fn ($type) => 'array' !== $type);
  227.                 $body = '
  228. /**
  229.  * @param ParamConfigurator|list<ParamConfigurator|PROTOTYPE_TYPE>EXTRA_TYPE $value
  230.  *
  231.  * @return $this
  232.  */
  233. public function NAME(PARAM_TYPE $value): static
  234. {
  235.     $this->_usedProperties[\'PROPERTY\'] = true;
  236.     $this->PROPERTY = $value;
  238.     return $this;
  239. }';
  241.                 $class->addMethod($node->getName(), $body, [
  242.                     'PROPERTY' => $property->getName(),
  243.                     'PROTOTYPE_TYPE' => implode('|', $prototypeParameterTypes),
  244.                     'EXTRA_TYPE' => $nodeTypesWithoutArray ? '|'.implode('|', $nodeTypesWithoutArray) : '',
  245.                     'PARAM_TYPE' => \in_array('mixed', $nodeParameterTypes, true) ? 'mixed' : 'ParamConfigurator|'.implode('|', $nodeParameterTypes),
  246.                 ]);
  247.             } else {
  248.                 $body = '
  249. /**
  250.  * @return $this
  251.  */
  252. public function NAME(string $VAR, TYPE $VALUE): static
  253. {
  254.     $this->_usedProperties[\'PROPERTY\'] = true;
  255.     $this->PROPERTY[$VAR] = $VALUE;
  257.     return $this;
  258. }';
  260.                 $class->addMethod($methodName, $body, [
  261.                     'PROPERTY' => $property->getName(),
  262.                     'TYPE' => \in_array('mixed', $prototypeParameterTypes, true) ? 'mixed' : 'ParamConfigurator|'.implode('|', $prototypeParameterTypes),
  263.                     'VAR' => '' === $key ? 'key' : $key,
  264.                     'VALUE' => 'value' === $key ? 'data' : 'value',
  265.                 ]);
  266.             }
  268.             return;
  269.         }
  271.         $childClass = new ClassBuilder($namespace, $name);
  272.         if ($prototype instanceof ArrayNode) {
  273.             $childClass->setAllowExtraKeys($prototype->shouldIgnoreExtraKeys());
  274.         }
  275.         $class->addRequire($childClass);
  276.         $this->classes[] = $childClass;
  278.         $property = $class->addProperty(
  279.             $node->getName(),
  280.             $this->getType($childClass->getFqcn().'[]', $hasNormalizationClosures)
  281.         );
  283.         $comment = $this->getComment($node);
  284.         if ($hasNormalizationClosures) {
  285.             $comment = sprintf(" * @template TValue\n * @param TValue \$value\n%s", $comment);
  286.             $comment .= sprintf(' * @return %s|$this'."\n", $childClass->getFqcn());
  287.             $comment .= sprintf(' * @psalm-return (TValue is array ? %s : static)'."\n ", $childClass->getFqcn());
  288.         }
  289.         if ('' !== $comment) {
  290.             $comment = "/**\n$comment*/\n";
  291.         }
  293.         if (null === $key = $node->getKeyAttribute()) {
  294.             $body = $hasNormalizationClosures ? '
  295. COMMENTpublic function NAME(PARAM_TYPE $value = []): CLASS|static
  296. {
  297.     $this->_usedProperties[\'PROPERTY\'] = true;
  298.     if (!\is_array($value)) {
  299.         $this->PROPERTY[] = $value;
  301.         return $this;
  302.     }
  304.     return $this->PROPERTY[] = new CLASS($value);
  305. }' : '
  306. COMMENTpublic function NAME(array $value = []): CLASS
  307. {
  308.     $this->_usedProperties[\'PROPERTY\'] = true;
  310.     return $this->PROPERTY[] = new CLASS($value);
  311. }';
  312.             $class->addMethod($methodName, $body, [
  313.                 'COMMENT' => $comment,
  314.                 'PROPERTY' => $property->getName(),
  315.                 'CLASS' => $childClass->getFqcn(),
  316.                 'PARAM_TYPE' => \in_array('mixed', $nodeParameterTypes, true) ? 'mixed' : implode('|', $nodeParameterTypes),
  317.             ]);
  318.         } else {
  319.             $body = $hasNormalizationClosures ? '
  320. COMMENTpublic function NAME(string $VAR, PARAM_TYPE $VALUE = []): CLASS|static
  321. {
  322.     if (!\is_array($VALUE)) {
  323.         $this->_usedProperties[\'PROPERTY\'] = true;
  324.         $this->PROPERTY[$VAR] = $VALUE;
  326.         return $this;
  327.     }
  329.     if (!isset($this->PROPERTY[$VAR]) || !$this->PROPERTY[$VAR] instanceof CLASS) {
  330.         $this->_usedProperties[\'PROPERTY\'] = true;
  331.         $this->PROPERTY[$VAR] = new CLASS($VALUE);
  332.     } elseif (1 < \func_num_args()) {
  333.         throw new InvalidConfigurationException(\'The node created by "NAME()" has already been initialized. You cannot pass values the second time you call NAME().\');
  334.     }
  336.     return $this->PROPERTY[$VAR];
  337. }' : '
  338. COMMENTpublic function NAME(string $VAR, array $VALUE = []): CLASS
  339. {
  340.     if (!isset($this->PROPERTY[$VAR])) {
  341.         $this->_usedProperties[\'PROPERTY\'] = true;
  342.         $this->PROPERTY[$VAR] = new CLASS($VALUE);
  343.     } elseif (1 < \func_num_args()) {
  344.         throw new InvalidConfigurationException(\'The node created by "NAME()" has already been initialized. You cannot pass values the second time you call NAME().\');
  345.     }
  347.     return $this->PROPERTY[$VAR];
  348. }';
  349.             $class->addUse(InvalidConfigurationException::class);
  350.             $class->addMethod($methodName, str_replace('$value', '$VAR', $body), [
  351.                 'COMMENT' => $comment, 'PROPERTY' => $property->getName(),
  352.                 'CLASS' => $childClass->getFqcn(),
  353.                 'VAR' => '' === $key ? 'key' : $key,
  354.                 'VALUE' => 'value' === $key ? 'data' : 'value',
  355.                 'PARAM_TYPE' => \in_array('mixed', $prototypeParameterTypes, true) ? 'mixed' : implode('|', $prototypeParameterTypes),
  356.             ]);
  357.         }
  359.         $this->buildNode($prototype, $childClass, $namespace.'\\'.$childClass->getName());
  360.     }
  362.     private function handleScalarNode(ScalarNode $node, ClassBuilder $class): void
  363.     {
  364.         $comment = $this->getComment($node);
  365.         $property = $class->addProperty($node->getName());
  366.         $class->addUse(ParamConfigurator::class);
  368.         $body = '
  369. /**
  370. COMMENT * @return $this
  371.  */
  372. public function NAME($value): static
  373. {
  374.     $this->_usedProperties[\'PROPERTY\'] = true;
  375.     $this->PROPERTY = $value;
  377.     return $this;
  378. }';
  380.         $class->addMethod($node->getName(), $body, ['PROPERTY' => $property->getName(), 'COMMENT' => $comment]);
  381.     }
  383.     private function getParameterTypes(NodeInterface $node): array
  384.     {
  385.         $paramTypes = [];
  386.         if ($node instanceof BaseNode) {
  387.             $types = $node->getNormalizedTypes();
  388.             if (\in_array(ExprBuilder::TYPE_ANY, $types, true)) {
  389.                 $paramTypes[] = 'mixed';
  390.             }
  391.             if (\in_array(ExprBuilder::TYPE_STRING, $types, true)) {
  392.                 $paramTypes[] = 'string';
  393.             }
  394.         }
  395.         if ($node instanceof BooleanNode) {
  396.             $paramTypes[] = 'bool';
  397.         } elseif ($node instanceof IntegerNode) {
  398.             $paramTypes[] = 'int';
  399.         } elseif ($node instanceof FloatNode) {
  400.             $paramTypes[] = 'float';
  401.         } elseif ($node instanceof EnumNode) {
  402.             $paramTypes[] = 'mixed';
  403.         } elseif ($node instanceof ArrayNode) {
  404.             $paramTypes[] = 'array';
  405.         } elseif ($node instanceof VariableNode) {
  406.             $paramTypes[] = 'mixed';
  407.         }
  409.         return array_unique($paramTypes);
  410.     }
  412.     private function getComment(BaseNode $node): string
  413.     {
  414.         $comment = '';
  415.         if ('' !== $info = (string) $node->getInfo()) {
  416.             $comment .= ' * '.$info."\n";
  417.         }
  419.         if (!$node instanceof ArrayNode) {
  420.             foreach ((array) ($node->getExample() ?? []) as $example) {
  421.                 $comment .= ' * @example '.$example."\n";
  422.             }
  424.             if ('' !== $default = $node->getDefaultValue()) {
  425.                 $comment .= ' * @default '.(null === $default ? 'null' : var_export($default, true))."\n";
  426.             }
  428.             if ($node instanceof EnumNode) {
  429.                 $comment .= sprintf(' * @param ParamConfigurator|%s $value', implode('|', array_map(function ($a) {
  430.                     return var_export($a, true);
  431.                 }, $node->getValues())))."\n";
  432.             } else {
  433.                 $parameterTypes = $this->getParameterTypes($node);
  434.                 $comment .= ' * @param ParamConfigurator|'.implode('|', $parameterTypes).' $value'."\n";
  435.             }
  436.         } else {
  437.             foreach ((array) ($node->getExample() ?? []) as $example) {
  438.                 $comment .= ' * @example '.json_encode($example)."\n";
  439.             }
  441.             if ($node->hasDefaultValue() && [] != $default = $node->getDefaultValue()) {
  442.                 $comment .= ' * @default '.json_encode($default)."\n";
  443.             }
  444.         }
  446.         if ($node->isDeprecated()) {
  447.             $comment .= ' * @deprecated '.$node->getDeprecation($node->getName(), $node->getParent()->getName())['message']."\n";
  448.         }
  450.         return $comment;
  451.     }
  453.     /**
  454.      * Pick a good singular name.
  455.      */
  456.     private function getSingularName(PrototypedArrayNode $node): string
  457.     {
  458.         $name = $node->getName();
  459.         if (!str_ends_with($name, 's')) {
  460.             return $name;
  461.         }
  463.         $parent = $node->getParent();
  464.         $mappings = $parent instanceof ArrayNode ? $parent->getXmlRemappings() : [];
  465.         foreach ($mappings as $map) {
  466.             if ($map[1] === $name) {
  467.                 $name = $map[0];
  468.                 break;
  469.             }
  470.         }
  472.         return $name;
  473.     }
  475.     private function buildToArray(ClassBuilder $class): void
  476.     {
  477.         $body = '$output = [];';
  478.         foreach ($class->getProperties() as $p) {
  479.             $code = '$this->PROPERTY';
  480.             if (null !== $p->getType()) {
  481.                 if ($p->isArray()) {
  482.                     $code = $p->areScalarsAllowed()
  483.                         ? 'array_map(function ($v) { return $v instanceof CLASS ? $v->toArray() : $v; }, $this->PROPERTY)'
  484.                         : 'array_map(function ($v) { return $v->toArray(); }, $this->PROPERTY)'
  485.                     ;
  486.                 } else {
  487.                     $code = $p->areScalarsAllowed()
  488.                         ? '$this->PROPERTY instanceof CLASS ? $this->PROPERTY->toArray() : $this->PROPERTY'
  489.                         : '$this->PROPERTY->toArray()'
  490.                     ;
  491.                 }
  492.             }
  494.             $body .= strtr('
  495.     if (isset($this->_usedProperties[\'PROPERTY\'])) {
  496.         $output[\'ORG_NAME\'] = '.$code.';
  497.     }', ['PROPERTY' => $p->getName(), 'ORG_NAME' => $p->getOriginalName(), 'CLASS' => $p->getType()]);
  498.         }
  500.         $extraKeys = $class->shouldAllowExtraKeys() ? ' + $this->_extraKeys' : '';
  502.         $class->addMethod('toArray', '
  503. public function NAME(): array
  504. {
  505.     '.$body.'
  507.     return $output'.$extraKeys.';
  508. }');
  509.     }
  511.     private function buildConstructor(ClassBuilder $class): void
  512.     {
  513.         $body = '';
  514.         foreach ($class->getProperties() as $p) {
  515.             $code = '$value[\'ORG_NAME\']';
  516.             if (null !== $p->getType()) {
  517.                 if ($p->isArray()) {
  518.                     $code = $p->areScalarsAllowed()
  519.                         ? 'array_map(function ($v) { return \is_array($v) ? new '.$p->getType().'($v) : $v; }, $value[\'ORG_NAME\'])'
  520.                         : 'array_map(function ($v) { return new '.$p->getType().'($v); }, $value[\'ORG_NAME\'])'
  521.                     ;
  522.                 } else {
  523.                     $code = $p->areScalarsAllowed()
  524.                         ? '\is_array($value[\'ORG_NAME\']) ? new '.$p->getType().'($value[\'ORG_NAME\']) : $value[\'ORG_NAME\']'
  525.                         : 'new '.$p->getType().'($value[\'ORG_NAME\'])'
  526.                     ;
  527.                 }
  528.             }
  530.             $body .= strtr('
  531.     if (array_key_exists(\'ORG_NAME\', $value)) {
  532.         $this->_usedProperties[\'PROPERTY\'] = true;
  533.         $this->PROPERTY = '.$code.';
  534.         unset($value[\'ORG_NAME\']);
  535.     }
  536. ', ['PROPERTY' => $p->getName(), 'ORG_NAME' => $p->getOriginalName()]);
  537.         }
  539.         if ($class->shouldAllowExtraKeys()) {
  540.             $body .= '
  541.     $this->_extraKeys = $value;
  542. ';
  543.         } else {
  544.             $body .= '
  545.     if ([] !== $value) {
  546.         throw new InvalidConfigurationException(sprintf(\'The following keys are not supported by "%s": \', __CLASS__).implode(\', \', array_keys($value)));
  547.     }';
  549.             $class->addUse(InvalidConfigurationException::class);
  550.         }
  552.         $class->addMethod('__construct', '
  553. public function __construct(array $value = [])
  554. {'.$body.'
  555. }');
  556.     }
  558.     private function buildSetExtraKey(ClassBuilder $class): void
  559.     {
  560.         if (!$class->shouldAllowExtraKeys()) {
  561.             return;
  562.         }
  564.         $class->addUse(ParamConfigurator::class);
  566.         $class->addProperty('_extraKeys');
  568.         $class->addMethod('set', '
  569. /**
  570.  * @param ParamConfigurator|mixed $value
  571.  *
  572.  * @return $this
  573.  */
  574. public function NAME(string $key, mixed $value): static
  575. {
  576.     $this->_extraKeys[$key] = $value;
  578.     return $this;
  579. }');
  580.     }
  582.     private function getSubNamespace(ClassBuilder $rootClass): string
  583.     {
  584.         return sprintf('%s\\%s', $rootClass->getNamespace(), substr($rootClass->getName(), 0, -6));
  585.     }
  587.     private function hasNormalizationClosures(NodeInterface $node): bool
  588.     {
  589.         try {
  590.             $r = new \ReflectionProperty($node, 'normalizationClosures');
  591.         } catch (\ReflectionException) {
  592.             return false;
  593.         }
  594.         $r->setAccessible(true);
  596.         return [] !== $r->getValue($node);
  597.     }
  599.     private function getType(string $classType, bool $hasNormalizationClosures): string
  600.     {
  601.         return $classType.($hasNormalizationClosures ? '|scalar' : '');
  602.     }
  603. }