vendor/symfony/var-exporter/ProxyHelper.php line 256

  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\VarExporter;
  14. use Symfony\Component\VarExporter\Exception\LogicException;
  15. use Symfony\Component\VarExporter\Internal\Hydrator;
  16. use Symfony\Component\VarExporter\Internal\LazyObjectRegistry;
  18. /**
  19.  * @author Nicolas Grekas <p@tchwork.com>
  20.  */
  21. final class ProxyHelper
  22. {
  23.     /**
  24.      * Helps generate lazy-loading ghost objects.
  25.      *
  26.      * @throws LogicException When the class is incompatible with ghost objects
  27.      */
  28.     public static function generateLazyGhost(\ReflectionClass $class): string
  29.     {
  30.         if (\PHP_VERSION_ID >= 80200 && \PHP_VERSION_ID < 80300 && $class->isReadOnly()) {
  31.             throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is readonly.', $class->name));
  32.         }
  33.         if ($class->isFinal()) {
  34.             throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is final.', $class->name));
  35.         }
  36.         if ($class->isInterface() || $class->isAbstract()) {
  37.             throw new LogicException(sprintf('Cannot generate lazy ghost: "%s" is not a concrete class.', $class->name));
  38.         }
  39.         if (\stdClass::class !== $class->name && $class->isInternal()) {
  40.             throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is internal.', $class->name));
  41.         }
  42.         if ($class->hasMethod('__get') && 'mixed' !== (self::exportType($class->getMethod('__get')) ?? 'mixed')) {
  43.             throw new LogicException(sprintf('Cannot generate lazy ghost: return type of method "%s::__get()" should be "mixed".', $class->name));
  44.         }
  46.         static $traitMethods;
  47.         $traitMethods ??= (new \ReflectionClass(LazyGhostTrait::class))->getMethods();
  49.         foreach ($traitMethods as $method) {
  50.             if ($class->hasMethod($method->name) && $class->getMethod($method->name)->isFinal()) {
  51.                 throw new LogicException(sprintf('Cannot generate lazy ghost: method "%s::%s()" is final.', $class->name, $method->name));
  52.             }
  53.         }
  55.         $parent = $class;
  56.         while ($parent = $parent->getParentClass()) {
  57.             if (\stdClass::class !== $parent->name && $parent->isInternal()) {
  58.                 throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" extends "%s" which is internal.', $class->name, $parent->name));
  59.             }
  60.         }
  61.         $propertyScopes = self::exportPropertyScopes($class->name);
  63.         return <<<EOPHP
  64.              extends \\{$class->name} implements \Symfony\Component\VarExporter\LazyObjectInterface
  65.             {
  66.                 use \Symfony\Component\VarExporter\LazyGhostTrait;
  68.                 private const LAZY_OBJECT_PROPERTY_SCOPES = {$propertyScopes};
  69.             }
  71.             // Help opcache.preload discover always-needed symbols
  72.             class_exists(\Symfony\Component\VarExporter\Internal\Hydrator::class);
  73.             class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectRegistry::class);
  74.             class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectState::class);
  76.             EOPHP;
  77.     }
  79.     /**
  80.      * Helps generate lazy-loading virtual proxies.
  81.      *
  82.      * @param \ReflectionClass[] $interfaces
  83.      *
  84.      * @throws LogicException When the class is incompatible with virtual proxies
  85.      */
  86.     public static function generateLazyProxy(?\ReflectionClass $class, array $interfaces = []): string
  87.     {
  88.         if (!class_exists($class?->name ?? \stdClass::class, false)) {
  89.             throw new LogicException(sprintf('Cannot generate lazy proxy: "%s" is not a class.', $class->name));
  90.         }
  91.         if ($class?->isFinal()) {
  92.             throw new LogicException(sprintf('Cannot generate lazy proxy: class "%s" is final.', $class->name));
  93.         }
  94.         if (\PHP_VERSION_ID >= 80200 && \PHP_VERSION_ID < 80300 && $class?->isReadOnly()) {
  95.             throw new LogicException(sprintf('Cannot generate lazy proxy: class "%s" is readonly.', $class->name));
  96.         }
  98.         $methodReflectors = [$class?->getMethods(\ReflectionMethod::IS_PUBLIC | \ReflectionMethod::IS_PROTECTED) ?? []];
  99.         foreach ($interfaces as $interface) {
  100.             if (!$interface->isInterface()) {
  101.                 throw new LogicException(sprintf('Cannot generate lazy proxy: "%s" is not an interface.', $interface->name));
  102.             }
  103.             $methodReflectors[] = $interface->getMethods();
  104.         }
  105.         $methodReflectors = array_merge(...$methodReflectors);
  107.         $extendsInternalClass = false;
  108.         if ($parent = $class) {
  109.             do {
  110.                 $extendsInternalClass = \stdClass::class !== $parent->name && $parent->isInternal();
  111.             } while (!$extendsInternalClass && $parent = $parent->getParentClass());
  112.         }
  113.         $methodsHaveToBeProxied = $extendsInternalClass;
  114.         $methods = [];
  116.         foreach ($methodReflectors as $method) {
  117.             if ('__get' !== strtolower($method->name) || 'mixed' === ($type = self::exportType($method) ?? 'mixed')) {
  118.                 continue;
  119.             }
  120.             $methodsHaveToBeProxied = true;
  121.             $trait = new \ReflectionMethod(LazyProxyTrait::class, '__get');
  122.             $body = \array_slice(file($trait->getFileName()), $trait->getStartLine() - 1, $trait->getEndLine() - $trait->getStartLine());
  123.             $body[0] = str_replace('): mixed', '): '.$type, $body[0]);
  124.             $methods['__get'] = strtr(implode('', $body).'    }', [
  125.                 'Hydrator' => '\\'.Hydrator::class,
  126.                 'Registry' => '\\'.LazyObjectRegistry::class,
  127.             ]);
  128.             break;
  129.         }
  131.         foreach ($methodReflectors as $method) {
  132.             if (($method->isStatic() && !$method->isAbstract()) || isset($methods[$lcName = strtolower($method->name)])) {
  133.                 continue;
  134.             }
  135.             if ($method->isFinal()) {
  136.                 if ($extendsInternalClass || $methodsHaveToBeProxied || method_exists(LazyProxyTrait::class, $method->name)) {
  137.                     throw new LogicException(sprintf('Cannot generate lazy proxy: method "%s::%s()" is final.', $class->name, $method->name));
  138.                 }
  139.                 continue;
  140.             }
  141.             if (method_exists(LazyProxyTrait::class, $method->name) || ($method->isProtected() && !$method->isAbstract())) {
  142.                 continue;
  143.             }
  145.             $signature = self::exportSignature($method);
  146.             $parentCall = $method->isAbstract() ? "throw new \BadMethodCallException('Cannot forward abstract method \"{$method->class}::{$method->name}()\".')" : "parent::{$method->name}(...\\func_get_args())";
  148.             if ($method->isStatic()) {
  149.                 $body = "        $parentCall;";
  150.             } elseif (str_ends_with($signature, '): never') || str_ends_with($signature, '): void')) {
  151.                 $body = <<<EOPHP
  152.                         if (isset(\$this->lazyObjectState)) {
  153.                             (\$this->lazyObjectState->realInstance ??= (\$this->lazyObjectState->initializer)())->{$method->name}(...\\func_get_args());
  154.                         } else {
  155.                             {$parentCall};
  156.                         }
  157.                 EOPHP;
  158.             } else {
  159.                 if (!$methodsHaveToBeProxied && !$method->isAbstract()) {
  160.                     // Skip proxying methods that might return $this
  161.                     foreach (preg_split('/[()|&]++/', self::exportType($method) ?? 'static') as $type) {
  162.                         if (\in_array($type = ltrim($type, '?'), ['static', 'object'], true)) {
  163.                             continue 2;
  164.                         }
  165.                         foreach ([$class, ...$interfaces] as $r) {
  166.                             if ($r && is_a($r->name, $type, true)) {
  167.                                 continue 3;
  168.                             }
  169.                         }
  170.                     }
  171.                 }
  173.                 $body = <<<EOPHP
  174.                         if (isset(\$this->lazyObjectState)) {
  175.                             return (\$this->lazyObjectState->realInstance ??= (\$this->lazyObjectState->initializer)())->{$method->name}(...\\func_get_args());
  176.                         }
  178.                         return {$parentCall};
  179.                 EOPHP;
  180.             }
  181.             $methods[$lcName] = "    {$signature}\n    {\n{$body}\n    }";
  182.         }
  184.         $types = $interfaces = array_unique(array_column($interfaces, 'name'));
  185.         $interfaces[] = LazyObjectInterface::class;
  186.         $interfaces = implode(', \\', $interfaces);
  187.         $parent = $class ? ' extends \\'.$class->name : '';
  188.         array_unshift($types, $class ? 'parent' : '');
  189.         $type = ltrim(implode('&\\', $types), '&');
  191.         if (!$class) {
  192.             $trait = new \ReflectionMethod(LazyProxyTrait::class, 'initializeLazyObject');
  193.             $body = \array_slice(file($trait->getFileName()), $trait->getStartLine() - 1, $trait->getEndLine() - $trait->getStartLine());
  194.             $body[0] = str_replace('): parent', '): '.$type, $body[0]);
  195.             $methods = ['initializeLazyObject' => implode('', $body).'    }'] + $methods;
  196.         }
  197.         $body = $methods ? "\n".implode("\n\n", $methods)."\n" : '';
  198.         $propertyScopes = $class ? self::exportPropertyScopes($class->name) : '[]';
  200.         return <<<EOPHP
  201.             {$parent} implements \\{$interfaces}
  202.             {
  203.                 use \Symfony\Component\VarExporter\LazyProxyTrait;
  205.                 private const LAZY_OBJECT_PROPERTY_SCOPES = {$propertyScopes};
  206.             {$body}}
  208.             // Help opcache.preload discover always-needed symbols
  209.             class_exists(\Symfony\Component\VarExporter\Internal\Hydrator::class);
  210.             class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectRegistry::class);
  211.             class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectState::class);
  213.             EOPHP;
  214.     }
  216.     public static function exportSignature(\ReflectionFunctionAbstract $function, bool $withParameterTypes = true): string
  217.     {
  218.         $parameters = [];
  219.         foreach ($function->getParameters() as $param) {
  220.             $parameters[] = ($param->getAttributes(\SensitiveParameter::class) ? '#[\SensitiveParameter] ' : '')
  221.                 .($withParameterTypes && $param->hasType() ? self::exportType($param).' ' : '')
  222.                 .($param->isPassedByReference() ? '&' : '')
  223.                 .($param->isVariadic() ? '...' : '').'$'.$param->name
  224.                 .($param->isOptional() && !$param->isVariadic() ? ' = '.self::exportDefault($param) : '');
  225.         }
  227.         $signature = 'function '.($function->returnsReference() ? '&' : '')
  228.             .($function->isClosure() ? '' : $function->name).'('.implode(', ', $parameters).')';
  230.         if ($function instanceof \ReflectionMethod) {
  231.             $signature = ($function->isPublic() ? 'public ' : ($function->isProtected() ? 'protected ' : 'private '))
  232.                 .($function->isStatic() ? 'static ' : '').$signature;
  233.         }
  234.         if ($function->hasReturnType()) {
  235.             $signature .= ': '.self::exportType($function);
  236.         }
  238.         static $getPrototype;
  239.         $getPrototype ??= (new \ReflectionMethod(\ReflectionMethod::class, 'getPrototype'))->invoke(...);
  241.         while ($function) {
  242.             if ($function->hasTentativeReturnType()) {
  243.                 return '#[\ReturnTypeWillChange] '.$signature;
  244.             }
  246.             try {
  247.                 $function = $function instanceof \ReflectionMethod && $function->isAbstract() ? false : $getPrototype($function);
  248.             } catch (\ReflectionException) {
  249.                 break;
  250.             }
  251.         }
  253.         return $signature;
  254.     }
  256.     public static function exportType(\ReflectionFunctionAbstract|\ReflectionProperty|\ReflectionParameter $owner, bool $noBuiltin = false, \ReflectionType $type = null): ?string
  257.     {
  258.         if (!$type ??= $owner instanceof \ReflectionFunctionAbstract ? $owner->getReturnType() : $owner->getType()) {
  259.             return null;
  260.         }
  261.         $class = null;
  262.         $types = [];
  263.         if ($type instanceof \ReflectionUnionType) {
  264.             $reflectionTypes = $type->getTypes();
  265.             $glue = '|';
  266.         } elseif ($type instanceof \ReflectionIntersectionType) {
  267.             $reflectionTypes = $type->getTypes();
  268.             $glue = '&';
  269.         } else {
  270.             $reflectionTypes = [$type];
  271.             $glue = null;
  272.         }
  274.         foreach ($reflectionTypes as $type) {
  275.             if ($type instanceof \ReflectionIntersectionType) {
  276.                 if ('' !== $name = '('.self::exportType($owner, $noBuiltin, $type).')') {
  277.                     $types[] = $name;
  278.                 }
  279.                 continue;
  280.             }
  281.             $name = $type->getName();
  283.             if ($noBuiltin && $type->isBuiltin()) {
  284.                 continue;
  285.             }
  286.             if (\in_array($name, ['parent', 'self'], true) && $class ??= $owner->getDeclaringClass()) {
  287.                 $name = 'parent' === $name ? ($class->getParentClass() ?: null)?->name ?? 'parent' : $class->name;
  288.             }
  290.             $types[] = ($noBuiltin || $type->isBuiltin() || 'static' === $name ? '' : '\\').$name;
  291.         }
  293.         if (!$types) {
  294.             return '';
  295.         }
  296.         if (null === $glue) {
  297.             return (!$noBuiltin && $type->allowsNull() && 'mixed' !== $name ? '?' : '').$types[0];
  298.         }
  299.         sort($types);
  301.         return implode($glue, $types);
  302.     }
  304.     private static function exportPropertyScopes(string $parent): string
  305.     {
  306.         $propertyScopes = Hydrator::$propertyScopes[$parent] ??= Hydrator::getPropertyScopes($parent);
  307.         uksort($propertyScopes, 'strnatcmp');
  308.         $propertyScopes = VarExporter::export($propertyScopes);
  309.         $propertyScopes = str_replace(VarExporter::export($parent), 'parent::class', $propertyScopes);
  310.         $propertyScopes = preg_replace("/(?|(,)\n( )       |\n        |,\n    (\]))/", '$1$2', $propertyScopes);
  311.         $propertyScopes = str_replace("\n", "\n    ", $propertyScopes);
  313.         return $propertyScopes;
  314.     }
  316.     private static function exportDefault(\ReflectionParameter $param): string
  317.     {
  318.         $default = rtrim(substr(explode('$'.$param->name.' = ', (string) $param, 2)[1] ?? '', 0, -2));
  320.         if (\in_array($default, ['<default>', 'NULL'], true)) {
  321.             return 'null';
  322.         }
  323.         if (str_ends_with($default, "...'") && preg_match("/^'(?:[^'\\\\]*+(?:\\\\.)*+)*+'$/", $default)) {
  324.             return VarExporter::export($param->getDefaultValue());
  325.         }
  327.         $regexp = "/(\"(?:[^\"\\\\]*+(?:\\\\.)*+)*+\"|'(?:[^'\\\\]*+(?:\\\\.)*+)*+')/";
  328.         $parts = preg_split($regexp, $default, -1, \PREG_SPLIT_DELIM_CAPTURE | \PREG_SPLIT_NO_EMPTY);
  330.         $regexp = '/([\[\( ]|^)([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+(?:\\\\[a-zA-Z0-9_\x7f-\xff]++)*+)(?!: )/';
  331.         $callback = (false !== strpbrk($default, "\\:('") && $class = $param->getDeclaringClass())
  332.             ? fn ($m) => $m[1].match ($m[2]) {
  333.                 'new', 'false', 'true', 'null' => $m[2],
  334.                 'NULL' => 'null',
  335.                 'self' => '\\'.$class->name,
  336.                 'namespace\\parent',
  337.                 'parent' => ($parent = $class->getParentClass()) ? '\\'.$parent->name : 'parent',
  338.                 default => '\\'.$m[2],
  339.             }
  340.             : fn ($m) => $m[1].match ($m[2]) {
  341.                 'new', 'false', 'true', 'null', 'self', 'parent' => $m[2],
  342.                 'NULL' => 'null',
  343.                 default => '\\'.$m[2],
  344.             };
  346.         return implode('', array_map(fn ($part) => match ($part[0]) {
  347.             '"' => $part, // for internal classes only
  348.             "'" => false !== strpbrk($part, "\\\0\r\n") ? '"'.substr(str_replace(['$', "\0", "\r", "\n"], ['\$', '\0', '\r', '\n'], $part), 1, -1).'"' : $part,
  349.             default => preg_replace_callback($regexp, $callback, $part),
  350.         }, $parts));
  351.     }
  352. }