vendor/symfony/property-access/PropertyAccessor.php line 100

Open in your IDE?
  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\PropertyAccess;
  14. use Psr\Cache\CacheItemPoolInterface;
  15. use Psr\Log\LoggerInterface;
  16. use Psr\Log\NullLogger;
  17. use Symfony\Component\Cache\Adapter\AdapterInterface;
  18. use Symfony\Component\Cache\Adapter\ApcuAdapter;
  19. use Symfony\Component\Cache\Adapter\NullAdapter;
  20. use Symfony\Component\PropertyAccess\Exception\AccessException;
  21. use Symfony\Component\PropertyAccess\Exception\InvalidArgumentException;
  22. use Symfony\Component\PropertyAccess\Exception\NoSuchIndexException;
  23. use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
  24. use Symfony\Component\PropertyAccess\Exception\UnexpectedTypeException;
  25. use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
  26. use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
  27. use Symfony\Component\PropertyInfo\PropertyReadInfo;
  28. use Symfony\Component\PropertyInfo\PropertyReadInfoExtractorInterface;
  29. use Symfony\Component\PropertyInfo\PropertyWriteInfo;
  30. use Symfony\Component\PropertyInfo\PropertyWriteInfoExtractorInterface;
  32. /**
  33.  * Default implementation of {@link PropertyAccessorInterface}.
  34.  *
  35.  * @author Bernhard Schussek <bschussek@gmail.com>
  36.  * @author Kévin Dunglas <dunglas@gmail.com>
  37.  * @author Nicolas Grekas <p@tchwork.com>
  38.  */
  39. class PropertyAccessor implements PropertyAccessorInterface
  40. {
  41.     /** @var int Allow none of the magic methods */
  42.     public const DISALLOW_MAGIC_METHODS = ReflectionExtractor::DISALLOW_MAGIC_METHODS;
  43.     /** @var int Allow magic __get methods */
  44.     public const MAGIC_GET = ReflectionExtractor::ALLOW_MAGIC_GET;
  45.     /** @var int Allow magic __set methods */
  46.     public const MAGIC_SET = ReflectionExtractor::ALLOW_MAGIC_SET;
  47.     /** @var int Allow magic __call methods */
  48.     public const MAGIC_CALL = ReflectionExtractor::ALLOW_MAGIC_CALL;
  50.     public const DO_NOT_THROW = 0;
  51.     public const THROW_ON_INVALID_INDEX = 1;
  52.     public const THROW_ON_INVALID_PROPERTY_PATH = 2;
  54.     private const VALUE = 0;
  55.     private const REF = 1;
  56.     private const IS_REF_CHAINED = 2;
  57.     private const CACHE_PREFIX_READ = 'r';
  58.     private const CACHE_PREFIX_WRITE = 'w';
  59.     private const CACHE_PREFIX_PROPERTY_PATH = 'p';
  61.     private $magicMethodsFlags;
  62.     private $ignoreInvalidIndices;
  63.     private $ignoreInvalidProperty;
  65.     /**
  66.      * @var CacheItemPoolInterface
  67.      */
  68.     private $cacheItemPool;
  70.     private $propertyPathCache = [];
  72.     /**
  73.      * @var PropertyReadInfoExtractorInterface
  74.      */
  75.     private $readInfoExtractor;
  77.     /**
  78.      * @var PropertyWriteInfoExtractorInterface
  79.      */
  80.     private $writeInfoExtractor;
  81.     private $readPropertyCache = [];
  82.     private $writePropertyCache = [];
  83.     private const RESULT_PROTO = [self::VALUE => null];
  85.     /**
  86.      * Should not be used by application code. Use
  87.      * {@link PropertyAccess::createPropertyAccessor()} instead.
  88.      *
  89.      * @param int                                 $magicMethods       A bitwise combination of the MAGIC_* constants
  90.      *                                                                to specify the allowed magic methods (__get, __set, __call)
  91.      *                                                                or self::DISALLOW_MAGIC_METHODS for none
  92.      * @param int                                 $throw              A bitwise combination of the THROW_* constants
  93.      *                                                                to specify when exceptions should be thrown
  94.      * @param PropertyReadInfoExtractorInterface  $readInfoExtractor
  95.      * @param PropertyWriteInfoExtractorInterface $writeInfoExtractor
  96.      */
  97.     public function __construct($magicMethods = self::MAGIC_GET | self::MAGIC_SET, $throw = self::THROW_ON_INVALID_PROPERTY_PATH, ?CacheItemPoolInterface $cacheItemPool = null, $readInfoExtractor = null, $writeInfoExtractor = null)
  98.     {
  99.         if (\is_bool($magicMethods)) {
  100.             trigger_deprecation('symfony/property-access', '5.2', 'Passing a boolean as the first argument to "%s()" is deprecated. Pass a combination of bitwise flags instead (i.e an integer).', __METHOD__);
  102.             $magicMethods = ($magicMethods ? self::MAGIC_CALL : 0) | self::MAGIC_GET | self::MAGIC_SET;
  103.         } elseif (!\is_int($magicMethods)) {
  104.             throw new \TypeError(sprintf('Argument 1 passed to "%s()" must be an integer, "%s" given.', __METHOD__, get_debug_type($readInfoExtractor)));
  105.         }
  107.         if (\is_bool($throw)) {
  108.             trigger_deprecation('symfony/property-access', '5.3', 'Passing a boolean as the second argument to "%s()" is deprecated. Pass a combination of bitwise flags instead (i.e an integer).', __METHOD__);
  110.             $throw = $throw ? self::THROW_ON_INVALID_INDEX : self::DO_NOT_THROW;
  112.             if (!\is_bool($readInfoExtractor)) {
  113.                 $throw |= self::THROW_ON_INVALID_PROPERTY_PATH;
  114.             }
  115.         }
  117.         if (\is_bool($readInfoExtractor)) {
  118.             trigger_deprecation('symfony/property-access', '5.3', 'Passing a boolean as the fourth argument to "%s()" is deprecated. Pass a combination of bitwise flags as the second argument instead (i.e an integer).', __METHOD__);
  120.             if ($readInfoExtractor) {
  121.                 $throw |= self::THROW_ON_INVALID_PROPERTY_PATH;
  122.             }
  124.             $readInfoExtractor = $writeInfoExtractor;
  125.             $writeInfoExtractor = 4 < \func_num_args() ? func_get_arg(4) : null;
  126.         }
  128.         if (null !== $readInfoExtractor && !$readInfoExtractor instanceof PropertyReadInfoExtractorInterface) {
  129.             throw new \TypeError(sprintf('Argument 4 passed to "%s()" must be null or an instance of "%s", "%s" given.', __METHOD__, PropertyReadInfoExtractorInterface::class, get_debug_type($readInfoExtractor)));
  130.         }
  132.         if (null !== $writeInfoExtractor && !$writeInfoExtractor instanceof PropertyWriteInfoExtractorInterface) {
  133.             throw new \TypeError(sprintf('Argument 5 passed to "%s()" must be null or an instance of "%s", "%s" given.', __METHOD__, PropertyWriteInfoExtractorInterface::class, get_debug_type($writeInfoExtractor)));
  134.         }
  136.         $this->magicMethodsFlags = $magicMethods;
  137.         $this->ignoreInvalidIndices = 0 === ($throw & self::THROW_ON_INVALID_INDEX);
  138.         $this->cacheItemPool = $cacheItemPool instanceof NullAdapter ? null : $cacheItemPool; // Replace the NullAdapter by the null value
  139.         $this->ignoreInvalidProperty = 0 === ($throw & self::THROW_ON_INVALID_PROPERTY_PATH);
  140.         $this->readInfoExtractor = $readInfoExtractor ?? new ReflectionExtractor([], null, null, false);
  141.         $this->writeInfoExtractor = $writeInfoExtractor ?? new ReflectionExtractor(['set'], null, null, false);
  142.     }
  144.     /**
  145.      * {@inheritdoc}
  146.      */
  147.     public function getValue($objectOrArray, $propertyPath)
  148.     {
  149.         $zval = [
  150.             self::VALUE => $objectOrArray,
  151.         ];
  153.         if (\is_object($objectOrArray) && (false === strpbrk((string) $propertyPath, '.[') || $objectOrArray instanceof \stdClass && property_exists($objectOrArray, $propertyPath))) {
  154.             return $this->readProperty($zval, $propertyPath, $this->ignoreInvalidProperty)[self::VALUE];
  155.         }
  157.         $propertyPath = $this->getPropertyPath($propertyPath);
  159.         $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength(), $this->ignoreInvalidIndices);
  161.         return $propertyValues[\count($propertyValues) - 1][self::VALUE];
  162.     }
  164.     /**
  165.      * {@inheritdoc}
  166.      */
  167.     public function setValue(&$objectOrArray, $propertyPath, $value)
  168.     {
  169.         if (\is_object($objectOrArray) && (false === strpbrk((string) $propertyPath, '.[') || $objectOrArray instanceof \stdClass && property_exists($objectOrArray, $propertyPath))) {
  170.             $zval = [
  171.                 self::VALUE => $objectOrArray,
  172.             ];
  174.             try {
  175.                 $this->writeProperty($zval, $propertyPath, $value);
  177.                 return;
  178.             } catch (\TypeError $e) {
  179.                 self::throwInvalidArgumentException($e->getMessage(), $e->getTrace(), 0, $propertyPath, $e);
  180.                 // It wasn't thrown in this class so rethrow it
  181.                 throw $e;
  182.             }
  183.         }
  185.         $propertyPath = $this->getPropertyPath($propertyPath);
  187.         $zval = [
  188.             self::VALUE => $objectOrArray,
  189.             self::REF => &$objectOrArray,
  190.         ];
  191.         $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength() - 1);
  192.         $overwrite = true;
  194.         try {
  195.             for ($i = \count($propertyValues) - 1; 0 <= $i; --$i) {
  196.                 $zval = $propertyValues[$i];
  197.                 unset($propertyValues[$i]);
  199.                 // You only need set value for current element if:
  200.                 // 1. it's the parent of the last index element
  201.                 // OR
  202.                 // 2. its child is not passed by reference
  203.                 //
  204.                 // This may avoid unnecessary value setting process for array elements.
  205.                 // For example:
  206.                 // '[a][b][c]' => 'old-value'
  207.                 // If you want to change its value to 'new-value',
  208.                 // you only need set value for '[a][b][c]' and it's safe to ignore '[a][b]' and '[a]'
  209.                 if ($overwrite) {
  210.                     $property = $propertyPath->getElement($i);
  212.                     if ($propertyPath->isIndex($i)) {
  213.                         if ($overwrite = !isset($zval[self::REF])) {
  214.                             $ref = &$zval[self::REF];
  215.                             $ref = $zval[self::VALUE];
  216.                         }
  217.                         $this->writeIndex($zval, $property, $value);
  218.                         if ($overwrite) {
  219.                             $zval[self::VALUE] = $zval[self::REF];
  220.                         }
  221.                     } else {
  222.                         $this->writeProperty($zval, $property, $value);
  223.                     }
  225.                     // if current element is an object
  226.                     // OR
  227.                     // if current element's reference chain is not broken - current element
  228.                     // as well as all its ancients in the property path are all passed by reference,
  229.                     // then there is no need to continue the value setting process
  230.                     if (\is_object($zval[self::VALUE]) || isset($zval[self::IS_REF_CHAINED])) {
  231.                         break;
  232.                     }
  233.                 }
  235.                 $value = $zval[self::VALUE];
  236.             }
  237.         } catch (\TypeError $e) {
  238.             self::throwInvalidArgumentException($e->getMessage(), $e->getTrace(), 0, $propertyPath, $e);
  240.             // It wasn't thrown in this class so rethrow it
  241.             throw $e;
  242.         }
  243.     }
  245.     private static function throwInvalidArgumentException(string $message, array $trace, int $i, string $propertyPath, ?\Throwable $previous = null): void
  246.     {
  247.         if (!isset($trace[$i]['file']) || __FILE__ !== $trace[$i]['file']) {
  248.             return;
  249.         }
  251.         if (\PHP_VERSION_ID < 80000) {
  252.             if (preg_match('/^Typed property \S+::\$\S+ must be (\S+), (\S+) used$/', $message, $matches)) {
  253.                 [, $expectedType, $actualType] = $matches;
  255.                 throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $expectedType, 'NULL' === $actualType ? 'null' : $actualType, $propertyPath), 0, $previous);
  256.             }
  258.             if (!str_starts_with($message, 'Argument ')) {
  259.                 return;
  260.             }
  262.             $pos = strpos($message, $delim = 'must be of the type ') ?: (strpos($message, $delim = 'must be an instance of ') ?: strpos($message, $delim = 'must implement interface '));
  263.             $pos += \strlen($delim);
  264.             $j = strpos($message, ',', $pos);
  265.             $type = substr($message, 2 + $j, strpos($message, ' given', $j) - $j - 2);
  266.             $message = substr($message, $pos, $j - $pos);
  268.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $message, 'NULL' === $type ? 'null' : $type, $propertyPath), 0, $previous);
  269.         }
  271.         if (preg_match('/^\S+::\S+\(\): Argument #\d+ \(\$\S+\) must be of type (\S+), (\S+) given/', $message, $matches)) {
  272.             [, $expectedType, $actualType] = $matches;
  274.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $expectedType, 'NULL' === $actualType ? 'null' : $actualType, $propertyPath), 0, $previous);
  275.         }
  276.         if (preg_match('/^Cannot assign (\S+) to property \S+::\$\S+ of type (\S+)$/', $message, $matches)) {
  277.             [, $actualType, $expectedType] = $matches;
  279.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $expectedType, 'NULL' === $actualType ? 'null' : $actualType, $propertyPath), 0, $previous);
  280.         }
  281.     }
  283.     /**
  284.      * {@inheritdoc}
  285.      */
  286.     public function isReadable($objectOrArray, $propertyPath)
  287.     {
  288.         if (!$propertyPath instanceof PropertyPathInterface) {
  289.             $propertyPath = new PropertyPath($propertyPath);
  290.         }
  292.         try {
  293.             $zval = [
  294.                 self::VALUE => $objectOrArray,
  295.             ];
  297.             // handle stdClass with properties with a dot in the name
  298.             if ($objectOrArray instanceof \stdClass && str_contains($propertyPath, '.')  && property_exists($objectOrArray, $propertyPath)) {
  299.                 $this->readProperty($zval, $propertyPath, $this->ignoreInvalidProperty);
  300.             } else {
  301.                 $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength(), $this->ignoreInvalidIndices);
  302.             }
  304.             return true;
  305.         } catch (AccessException $e) {
  306.             return false;
  307.         } catch (UnexpectedTypeException $e) {
  308.             return false;
  309.         }
  310.     }
  312.     /**
  313.      * {@inheritdoc}
  314.      */
  315.     public function isWritable($objectOrArray, $propertyPath)
  316.     {
  317.         $propertyPath = $this->getPropertyPath($propertyPath);
  319.         try {
  320.             $zval = [
  321.                 self::VALUE => $objectOrArray,
  322.             ];
  324.             // handle stdClass with properties with a dot in the name
  325.             if ($objectOrArray instanceof \stdClass && str_contains($propertyPath, '.') && property_exists($objectOrArray, $propertyPath)) {
  326.                 $this->readProperty($zval, $propertyPath, $this->ignoreInvalidProperty);
  328.                 return true;
  329.             }
  331.             $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength() - 1);
  333.             for ($i = \count($propertyValues) - 1; 0 <= $i; --$i) {
  334.                 $zval = $propertyValues[$i];
  335.                 unset($propertyValues[$i]);
  337.                 if ($propertyPath->isIndex($i)) {
  338.                     if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  339.                         return false;
  340.                     }
  341.                 } elseif (!\is_object($zval[self::VALUE]) || !$this->isPropertyWritable($zval[self::VALUE], $propertyPath->getElement($i))) {
  342.                     return false;
  343.                 }
  345.                 if (\is_object($zval[self::VALUE])) {
  346.                     return true;
  347.                 }
  348.             }
  350.             return true;
  351.         } catch (AccessException $e) {
  352.             return false;
  353.         } catch (UnexpectedTypeException $e) {
  354.             return false;
  355.         }
  356.     }
  358.     /**
  359.      * Reads the path from an object up to a given path index.
  360.      *
  361.      * @throws UnexpectedTypeException if a value within the path is neither object nor array
  362.      * @throws NoSuchIndexException    If a non-existing index is accessed
  363.      */
  364.     private function readPropertiesUntil(array $zval, PropertyPathInterface $propertyPath, int $lastIndex, bool $ignoreInvalidIndices = true): array
  365.     {
  366.         if (!\is_object($zval[self::VALUE]) && !\is_array($zval[self::VALUE])) {
  367.             throw new UnexpectedTypeException($zval[self::VALUE], $propertyPath, 0);
  368.         }
  370.         // Add the root object to the list
  371.         $propertyValues = [$zval];
  373.         for ($i = 0; $i < $lastIndex; ++$i) {
  374.             $property = $propertyPath->getElement($i);
  375.             $isIndex = $propertyPath->isIndex($i);
  377.             if ($isIndex) {
  378.                 // Create missing nested arrays on demand
  379.                 if (($zval[self::VALUE] instanceof \ArrayAccess && !$zval[self::VALUE]->offsetExists($property)) ||
  380.                     (\is_array($zval[self::VALUE]) && !isset($zval[self::VALUE][$property]) && !\array_key_exists($property, $zval[self::VALUE]))
  381.                 ) {
  382.                     if (!$ignoreInvalidIndices) {
  383.                         if (!\is_array($zval[self::VALUE])) {
  384.                             if (!$zval[self::VALUE] instanceof \Traversable) {
  385.                                 throw new NoSuchIndexException(sprintf('Cannot read index "%s" while trying to traverse path "%s".', $property, (string) $propertyPath));
  386.                             }
  388.                             $zval[self::VALUE] = iterator_to_array($zval[self::VALUE]);
  389.                         }
  391.                         throw new NoSuchIndexException(sprintf('Cannot read index "%s" while trying to traverse path "%s". Available indices are "%s".', $property, (string) $propertyPath, print_r(array_keys($zval[self::VALUE]), true)));
  392.                     }
  394.                     if ($i + 1 < $propertyPath->getLength()) {
  395.                         if (isset($zval[self::REF])) {
  396.                             $zval[self::VALUE][$property] = [];
  397.                             $zval[self::REF] = $zval[self::VALUE];
  398.                         } else {
  399.                             $zval[self::VALUE] = [$property => []];
  400.                         }
  401.                     }
  402.                 }
  404.                 $zval = $this->readIndex($zval, $property);
  405.             } else {
  406.                 $zval = $this->readProperty($zval, $property, $this->ignoreInvalidProperty);
  407.             }
  409.             // the final value of the path must not be validated
  410.             if ($i + 1 < $propertyPath->getLength() && !\is_object($zval[self::VALUE]) && !\is_array($zval[self::VALUE])) {
  411.                 throw new UnexpectedTypeException($zval[self::VALUE], $propertyPath, $i + 1);
  412.             }
  414.             if (isset($zval[self::REF]) && (0 === $i || isset($propertyValues[$i - 1][self::IS_REF_CHAINED]))) {
  415.                 // Set the IS_REF_CHAINED flag to true if:
  416.                 // current property is passed by reference and
  417.                 // it is the first element in the property path or
  418.                 // the IS_REF_CHAINED flag of its parent element is true
  419.                 // Basically, this flag is true only when the reference chain from the top element to current element is not broken
  420.                 $zval[self::IS_REF_CHAINED] = true;
  421.             }
  423.             $propertyValues[] = $zval;
  424.         }
  426.         return $propertyValues;
  427.     }
  429.     /**
  430.      * Reads a key from an array-like structure.
  431.      *
  432.      * @param string|int $index The key to read
  433.      *
  434.      * @throws NoSuchIndexException If the array does not implement \ArrayAccess or it is not an array
  435.      */
  436.     private function readIndex(array $zval, $index): array
  437.     {
  438.         if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  439.             throw new NoSuchIndexException(sprintf('Cannot read index "%s" from object of type "%s" because it doesn\'t implement \ArrayAccess.', $index, get_debug_type($zval[self::VALUE])));
  440.         }
  442.         $result = self::RESULT_PROTO;
  444.         if (isset($zval[self::VALUE][$index])) {
  445.             $result[self::VALUE] = $zval[self::VALUE][$index];
  447.             if (!isset($zval[self::REF])) {
  448.                 // Save creating references when doing read-only lookups
  449.             } elseif (\is_array($zval[self::VALUE])) {
  450.                 $result[self::REF] = &$zval[self::REF][$index];
  451.             } elseif (\is_object($result[self::VALUE])) {
  452.                 $result[self::REF] = $result[self::VALUE];
  453.             }
  454.         }
  456.         return $result;
  457.     }
  459.     /**
  460.      * Reads the value of a property from an object.
  461.      *
  462.      * @throws NoSuchPropertyException If $ignoreInvalidProperty is false and the property does not exist or is not public
  463.      */
  464.     private function readProperty(array $zval, string $property, bool $ignoreInvalidProperty = false): array
  465.     {
  466.         if (!\is_object($zval[self::VALUE])) {
  467.             throw new NoSuchPropertyException(sprintf('Cannot read property "%s" from an array. Maybe you intended to write the property path as "[%1$s]" instead.', $property));
  468.         }
  470.         $result = self::RESULT_PROTO;
  471.         $object = $zval[self::VALUE];
  472.         $class = \get_class($object);
  473.         $access = $this->getReadInfo($class, $property);
  475.         if (null !== $access) {
  476.             $name = $access->getName();
  477.             $type = $access->getType();
  479.             try {
  480.                 if (PropertyReadInfo::TYPE_METHOD === $type) {
  481.                     try {
  482.                         $result[self::VALUE] = $object->$name();
  483.                     } catch (\TypeError $e) {
  484.                         [$trace] = $e->getTrace();
  486.                         // handle uninitialized properties in PHP >= 7
  487.                         if (__FILE__ === ($trace['file'] ?? null)
  488.                             && $name === $trace['function']
  489.                             && $object instanceof $trace['class']
  490.                             && preg_match('/Return value (?:of .*::\w+\(\) )?must be of (?:the )?type (\w+), null returned$/', $e->getMessage(), $matches)
  491.                         ) {
  492.                             throw new UninitializedPropertyException(sprintf('The method "%s::%s()" returned "null", but expected type "%3$s". Did you forget to initialize a property or to make the return type nullable using "?%3$s"?', get_debug_type($object), $name, $matches[1]), 0, $e);
  493.                         }
  495.                         throw $e;
  496.                     }
  497.                 } elseif (PropertyReadInfo::TYPE_PROPERTY === $type) {
  498.                     if ($access->canBeReference() && !isset($object->$name) && !\array_key_exists($name, (array) $object) && (\PHP_VERSION_ID < 70400 || !(new \ReflectionProperty($class, $name))->hasType())) {
  499.                         throw new UninitializedPropertyException(sprintf('The property "%s::$%s" is not initialized.', $class, $name));
  500.                     }
  502.                     $result[self::VALUE] = $object->$name;
  504.                     if (isset($zval[self::REF]) && $access->canBeReference()) {
  505.                         $result[self::REF] = &$object->$name;
  506.                     }
  507.                 }
  508.             } catch (\Error $e) {
  509.                 // handle uninitialized properties in PHP >= 7.4
  510.                 if (\PHP_VERSION_ID >= 70400 && preg_match('/^Typed property ([\w\\\\@]+)::\$(\w+) must not be accessed before initialization$/', $e->getMessage(), $matches)) {
  511.                     $r = new \ReflectionProperty(str_contains($matches[1], '@anonymous') ? $class : $matches[1], $matches[2]);
  512.                     $type = ($type = $r->getType()) instanceof \ReflectionNamedType ? $type->getName() : (string) $type;
  514.                     throw new UninitializedPropertyException(sprintf('The property "%s::$%s" is not readable because it is typed "%s". You should initialize it or declare a default value instead.', $matches[1], $r->getName(), $type), 0, $e);
  515.                 }
  517.                 throw $e;
  518.             }
  519.         } elseif (property_exists($object, $property) && \array_key_exists($property, (array) $object)) {
  520.             $result[self::VALUE] = $object->$property;
  521.             if (isset($zval[self::REF])) {
  522.                 $result[self::REF] = &$object->$property;
  523.             }
  524.         } elseif (!$ignoreInvalidProperty) {
  525.             throw new NoSuchPropertyException(sprintf('Can\'t get a way to read the property "%s" in class "%s".', $property, $class));
  526.         }
  528.         // Objects are always passed around by reference
  529.         if (isset($zval[self::REF]) && \is_object($result[self::VALUE])) {
  530.             $result[self::REF] = $result[self::VALUE];
  531.         }
  533.         return $result;
  534.     }
  536.     /**
  537.      * Guesses how to read the property value.
  538.      */
  539.     private function getReadInfo(string $class, string $property): ?PropertyReadInfo
  540.     {
  541.         $key = str_replace('\\', '.', $class).'..'.$property;
  543.         if (isset($this->readPropertyCache[$key])) {
  544.             return $this->readPropertyCache[$key];
  545.         }
  547.         if ($this->cacheItemPool) {
  548.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_READ.rawurlencode($key));
  549.             if ($item->isHit()) {
  550.                 return $this->readPropertyCache[$key] = $item->get();
  551.             }
  552.         }
  554.         $accessor = $this->readInfoExtractor->getReadInfo($class, $property, [
  555.             'enable_getter_setter_extraction' => true,
  556.             'enable_magic_methods_extraction' => $this->magicMethodsFlags,
  557.             'enable_constructor_extraction' => false,
  558.         ]);
  560.         if (isset($item)) {
  561.             $this->cacheItemPool->save($item->set($accessor));
  562.         }
  564.         return $this->readPropertyCache[$key] = $accessor;
  565.     }
  567.     /**
  568.      * Sets the value of an index in a given array-accessible value.
  569.      *
  570.      * @param string|int $index The index to write at
  571.      * @param mixed      $value The value to write
  572.      *
  573.      * @throws NoSuchIndexException If the array does not implement \ArrayAccess or it is not an array
  574.      */
  575.     private function writeIndex(array $zval, $index, $value)
  576.     {
  577.         if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  578.             throw new NoSuchIndexException(sprintf('Cannot modify index "%s" in object of type "%s" because it doesn\'t implement \ArrayAccess.', $index, get_debug_type($zval[self::VALUE])));
  579.         }
  581.         $zval[self::REF][$index] = $value;
  582.     }
  584.     /**
  585.      * Sets the value of a property in the given object.
  586.      *
  587.      * @param mixed $value The value to write
  588.      *
  589.      * @throws NoSuchPropertyException if the property does not exist or is not public
  590.      */
  591.     private function writeProperty(array $zval, string $property, $value)
  592.     {
  593.         if (!\is_object($zval[self::VALUE])) {
  594.             throw new NoSuchPropertyException(sprintf('Cannot write property "%s" to an array. Maybe you should write the property path as "[%1$s]" instead?', $property));
  595.         }
  597.         $object = $zval[self::VALUE];
  598.         $class = \get_class($object);
  599.         $mutator = $this->getWriteInfo($class, $property, $value);
  601.         if (PropertyWriteInfo::TYPE_NONE !== $mutator->getType()) {
  602.             $type = $mutator->getType();
  604.             if (PropertyWriteInfo::TYPE_METHOD === $type) {
  605.                 $object->{$mutator->getName()}($value);
  606.             } elseif (PropertyWriteInfo::TYPE_PROPERTY === $type) {
  607.                 $object->{$mutator->getName()} = $value;
  608.             } elseif (PropertyWriteInfo::TYPE_ADDER_AND_REMOVER === $type) {
  609.                 $this->writeCollection($zval, $property, $value, $mutator->getAdderInfo(), $mutator->getRemoverInfo());
  610.             }
  611.         } elseif ($object instanceof \stdClass && property_exists($object, $property)) {
  612.             $object->$property = $value;
  613.         } elseif (!$this->ignoreInvalidProperty) {
  614.             if ($mutator->hasErrors()) {
  615.                 throw new NoSuchPropertyException(implode('. ', $mutator->getErrors()).'.');
  616.             }
  618.             throw new NoSuchPropertyException(sprintf('Could not determine access type for property "%s" in class "%s".', $property, get_debug_type($object)));
  619.         }
  620.     }
  622.     /**
  623.      * Adjusts a collection-valued property by calling add*() and remove*() methods.
  624.      */
  625.     private function writeCollection(array $zval, string $property, iterable $collection, PropertyWriteInfo $addMethod, PropertyWriteInfo $removeMethod)
  626.     {
  627.         // At this point the add and remove methods have been found
  628.         $previousValue = $this->readProperty($zval, $property);
  629.         $previousValue = $previousValue[self::VALUE];
  631.         $removeMethodName = $removeMethod->getName();
  632.         $addMethodName = $addMethod->getName();
  634.         if ($previousValue instanceof \Traversable) {
  635.             $previousValue = iterator_to_array($previousValue);
  636.         }
  637.         if ($previousValue && \is_array($previousValue)) {
  638.             if (\is_object($collection)) {
  639.                 $collection = iterator_to_array($collection);
  640.             }
  641.             foreach ($previousValue as $key => $item) {
  642.                 if (!\in_array($item, $collection, true)) {
  643.                     unset($previousValue[$key]);
  644.                     $zval[self::VALUE]->$removeMethodName($item);
  645.                 }
  646.             }
  647.         } else {
  648.             $previousValue = false;
  649.         }
  651.         foreach ($collection as $item) {
  652.             if (!$previousValue || !\in_array($item, $previousValue, true)) {
  653.                 $zval[self::VALUE]->$addMethodName($item);
  654.             }
  655.         }
  656.     }
  658.     private function getWriteInfo(string $class, string $property, $value): PropertyWriteInfo
  659.     {
  660.         $useAdderAndRemover = is_iterable($value);
  661.         $key = str_replace('\\', '.', $class).'..'.$property.'..'.(int) $useAdderAndRemover;
  663.         if (isset($this->writePropertyCache[$key])) {
  664.             return $this->writePropertyCache[$key];
  665.         }
  667.         if ($this->cacheItemPool) {
  668.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_WRITE.rawurlencode($key));
  669.             if ($item->isHit()) {
  670.                 return $this->writePropertyCache[$key] = $item->get();
  671.             }
  672.         }
  674.         $mutator = $this->writeInfoExtractor->getWriteInfo($class, $property, [
  675.             'enable_getter_setter_extraction' => true,
  676.             'enable_magic_methods_extraction' => $this->magicMethodsFlags,
  677.             'enable_constructor_extraction' => false,
  678.             'enable_adder_remover_extraction' => $useAdderAndRemover,
  679.         ]);
  681.         if (isset($item)) {
  682.             $this->cacheItemPool->save($item->set($mutator));
  683.         }
  685.         return $this->writePropertyCache[$key] = $mutator;
  686.     }
  688.     /**
  689.      * Returns whether a property is writable in the given object.
  690.      */
  691.     private function isPropertyWritable(object $object, string $property): bool
  692.     {
  693.         $mutatorForArray = $this->getWriteInfo(\get_class($object), $property, []);
  695.         if (PropertyWriteInfo::TYPE_NONE !== $mutatorForArray->getType() || ($object instanceof \stdClass && property_exists($object, $property))) {
  696.             return true;
  697.         }
  699.         $mutator = $this->getWriteInfo(\get_class($object), $property, '');
  701.         return PropertyWriteInfo::TYPE_NONE !== $mutator->getType() || ($object instanceof \stdClass && property_exists($object, $property));
  702.     }
  704.     /**
  705.      * Gets a PropertyPath instance and caches it.
  706.      *
  707.      * @param string|PropertyPath $propertyPath
  708.      */
  709.     private function getPropertyPath($propertyPath): PropertyPath
  710.     {
  711.         if ($propertyPath instanceof PropertyPathInterface) {
  712.             // Don't call the copy constructor has it is not needed here
  713.             return $propertyPath;
  714.         }
  716.         if (isset($this->propertyPathCache[$propertyPath])) {
  717.             return $this->propertyPathCache[$propertyPath];
  718.         }
  720.         if ($this->cacheItemPool) {
  721.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_PROPERTY_PATH.rawurlencode($propertyPath));
  722.             if ($item->isHit()) {
  723.                 return $this->propertyPathCache[$propertyPath] = $item->get();
  724.             }
  725.         }
  727.         $propertyPathInstance = new PropertyPath($propertyPath);
  728.         if (isset($item)) {
  729.             $item->set($propertyPathInstance);
  730.             $this->cacheItemPool->save($item);
  731.         }
  733.         return $this->propertyPathCache[$propertyPath] = $propertyPathInstance;
  734.     }
  736.     /**
  737.      * Creates the APCu adapter if applicable.
  738.      *
  739.      * @return AdapterInterface
  740.      *
  741.      * @throws \LogicException When the Cache Component isn't available
  742.      */
  743.     public static function createCache(string $namespace, int $defaultLifetime, string $version, ?LoggerInterface $logger = null)
  744.     {
  745.         if (!class_exists(ApcuAdapter::class)) {
  746.             throw new \LogicException(sprintf('The Symfony Cache component must be installed to use "%s()".', __METHOD__));
  747.         }
  749.         if (!ApcuAdapter::isSupported()) {
  750.             return new NullAdapter();
  751.         }
  753.         $apcu = new ApcuAdapter($namespace, $defaultLifetime / 5, $version);
  754.         if ('cli' === \PHP_SAPI && !filter_var(\ini_get('apc.enable_cli'), \FILTER_VALIDATE_BOOLEAN)) {
  755.             $apcu->setLogger(new NullLogger());
  756.         } elseif (null !== $logger) {
  757.             $apcu->setLogger($logger);
  758.         }
  760.         return $apcu;
  761.     }
  762. }