vendor/doctrine/common/src/Proxy/ProxyGenerator.php line 328

Open in your IDE?
  1. <?php
  3. namespace Doctrine\Common\Proxy;
  5. use BackedEnum;
  6. use Doctrine\Common\Proxy\Exception\InvalidArgumentException;
  7. use Doctrine\Common\Proxy\Exception\UnexpectedValueException;
  8. use Doctrine\Common\Util\ClassUtils;
  9. use Doctrine\Persistence\Mapping\ClassMetadata;
  10. use ReflectionIntersectionType;
  11. use ReflectionMethod;
  12. use ReflectionNamedType;
  13. use ReflectionParameter;
  14. use ReflectionProperty;
  15. use ReflectionType;
  16. use ReflectionUnionType;
  18. use function array_combine;
  19. use function array_diff;
  20. use function array_key_exists;
  21. use function array_map;
  22. use function array_slice;
  23. use function array_unique;
  24. use function assert;
  25. use function bin2hex;
  26. use function call_user_func;
  27. use function chmod;
  28. use function class_exists;
  29. use function dirname;
  30. use function explode;
  31. use function file;
  32. use function file_put_contents;
  33. use function get_class;
  34. use function implode;
  35. use function in_array;
  36. use function interface_exists;
  37. use function is_callable;
  38. use function is_dir;
  39. use function is_scalar;
  40. use function is_string;
  41. use function is_writable;
  42. use function lcfirst;
  43. use function ltrim;
  44. use function method_exists;
  45. use function mkdir;
  46. use function preg_match;
  47. use function preg_match_all;
  48. use function preg_replace;
  49. use function preg_split;
  50. use function random_bytes;
  51. use function rename;
  52. use function rtrim;
  53. use function sprintf;
  54. use function str_replace;
  55. use function strpos;
  56. use function strrev;
  57. use function strtolower;
  58. use function strtr;
  59. use function substr;
  60. use function trim;
  61. use function var_export;
  63. use const DIRECTORY_SEPARATOR;
  64. use const PHP_VERSION_ID;
  65. use const PREG_SPLIT_DELIM_CAPTURE;
  67. /**
  68.  * This factory is used to generate proxy classes.
  69.  * It builds proxies from given parameters, a template and class metadata.
  70.  */
  71. class ProxyGenerator
  72. {
  73.     /**
  74.      * Used to match very simple id methods that don't need
  75.      * to be decorated since the identifier is known.
  76.      */
  77.     public const PATTERN_MATCH_ID_METHOD = <<<'EOT'
  78. ((?(DEFINE)
  79.   (?<type>\\?[a-z_\x7f-\xff][\w\x7f-\xff]*(?:\\[a-z_\x7f-\xff][\w\x7f-\xff]*)*)
  80.   (?<intersection_type>(?&type)\s*&\s*(?&type))
  81.   (?<union_type>(?:(?:\(\s*(?&intersection_type)\s*\))|(?&type))(?:\s*\|\s*(?:(?:\(\s*(?&intersection_type)\s*\))|(?&type)))+)
  82. )(?:public\s+)?(?:function\s+%s\s*\(\)\s*)\s*(?::\s*(?:(?&union_type)|(?&intersection_type)|(?:\??(?&type)))\s*)?{\s*return\s*\$this->%s;\s*})i
  83. EOT;
  85.     /**
  86.      * The namespace that contains all proxy classes.
  87.      *
  88.      * @var string
  89.      */
  90.     private $proxyNamespace;
  92.     /**
  93.      * The directory that contains all proxy classes.
  94.      *
  95.      * @var string
  96.      */
  97.     private $proxyDirectory;
  99.     /**
  100.      * Map of callables used to fill in placeholders set in the template.
  101.      *
  102.      * @var string[]|callable[]
  103.      */
  104.     protected $placeholders = [
  105.         'baseProxyInterface'   => Proxy::class,
  106.         'additionalProperties' => '',
  107.     ];
  109.     /**
  110.      * Template used as a blueprint to generate proxies.
  111.      *
  112.      * @var string
  113.      */
  114.     protected $proxyClassTemplate = '<?php
  116. namespace <namespace>;
  117. <enumUseStatements>
  118. /**
  119.  * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE\'S PROXY GENERATOR
  120.  */
  121. class <proxyShortClassName> extends \<className> implements \<baseProxyInterface>
  122. {
  123.     /**
  124.      * @var \Closure the callback responsible for loading properties in the proxy object. This callback is called with
  125.      *      three parameters, being respectively the proxy object to be initialized, the method that triggered the
  126.      *      initialization process and an array of ordered parameters that were passed to that method.
  127.      *
  128.      * @see \Doctrine\Common\Proxy\Proxy::__setInitializer
  129.      */
  130.     public $__initializer__;
  132.     /**
  133.      * @var \Closure the callback responsible of loading properties that need to be copied in the cloned object
  134.      *
  135.      * @see \Doctrine\Common\Proxy\Proxy::__setCloner
  136.      */
  137.     public $__cloner__;
  139.     /**
  140.      * @var boolean flag indicating if this object was already initialized
  141.      *
  142.      * @see \Doctrine\Persistence\Proxy::__isInitialized
  143.      */
  144.     public $__isInitialized__ = false;
  146.     /**
  147.      * @var array<string, null> properties to be lazy loaded, indexed by property name
  148.      */
  149.     public static $lazyPropertiesNames = <lazyPropertiesNames>;
  151.     /**
  152.      * @var array<string, mixed> default values of properties to be lazy loaded, with keys being the property names
  153.      *
  154.      * @see \Doctrine\Common\Proxy\Proxy::__getLazyProperties
  155.      */
  156.     public static $lazyPropertiesDefaults = <lazyPropertiesDefaults>;
  158. <additionalProperties>
  160. <constructorImpl>
  162. <magicGet>
  164. <magicSet>
  166. <magicIsset>
  168. <sleepImpl>
  170. <wakeupImpl>
  172. <cloneImpl>
  174.     /**
  175.      * Forces initialization of the proxy
  176.      */
  177.     public function __load(): void
  178.     {
  179.         $this->__initializer__ && $this->__initializer__->__invoke($this, \'__load\', []);
  180.     }
  182.     /**
  183.      * {@inheritDoc}
  184.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  185.      */
  186.     public function __isInitialized(): bool
  187.     {
  188.         return $this->__isInitialized__;
  189.     }
  191.     /**
  192.      * {@inheritDoc}
  193.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  194.      */
  195.     public function __setInitialized($initialized): void
  196.     {
  197.         $this->__isInitialized__ = $initialized;
  198.     }
  200.     /**
  201.      * {@inheritDoc}
  202.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  203.      */
  204.     public function __setInitializer(\Closure $initializer = null): void
  205.     {
  206.         $this->__initializer__ = $initializer;
  207.     }
  209.     /**
  210.      * {@inheritDoc}
  211.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  212.      */
  213.     public function __getInitializer(): ?\Closure
  214.     {
  215.         return $this->__initializer__;
  216.     }
  218.     /**
  219.      * {@inheritDoc}
  220.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  221.      */
  222.     public function __setCloner(\Closure $cloner = null): void
  223.     {
  224.         $this->__cloner__ = $cloner;
  225.     }
  227.     /**
  228.      * {@inheritDoc}
  229.      * @internal generated method: use only when explicitly handling proxy specific cloning logic
  230.      */
  231.     public function __getCloner(): ?\Closure
  232.     {
  233.         return $this->__cloner__;
  234.     }
  236.     /**
  237.      * {@inheritDoc}
  238.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  239.      * @deprecated no longer in use - generated code now relies on internal components rather than generated public API
  240.      * @static
  241.      */
  242.     public function __getLazyProperties(): array
  243.     {
  244.         return self::$lazyPropertiesDefaults;
  245.     }
  247.     <methods>
  248. }
  249. ';
  251.     /**
  252.      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
  253.      * connected to the given <tt>EntityManager</tt>.
  254.      *
  255.      * @param string $proxyDirectory The directory to use for the proxy classes. It must exist.
  256.      * @param string $proxyNamespace The namespace to use for the proxy classes.
  257.      *
  258.      * @throws InvalidArgumentException
  259.      */
  260.     public function __construct($proxyDirectory, $proxyNamespace)
  261.     {
  262.         if (! $proxyDirectory) {
  263.             throw InvalidArgumentException::proxyDirectoryRequired();
  264.         }
  266.         if (! $proxyNamespace) {
  267.             throw InvalidArgumentException::proxyNamespaceRequired();
  268.         }
  270.         $this->proxyDirectory = $proxyDirectory;
  271.         $this->proxyNamespace = $proxyNamespace;
  272.     }
  274.     /**
  275.      * Sets a placeholder to be replaced in the template.
  276.      *
  277.      * @param string          $name
  278.      * @param string|callable $placeholder
  279.      *
  280.      * @throws InvalidArgumentException
  281.      */
  282.     public function setPlaceholder($name, $placeholder)
  283.     {
  284.         if (! is_string($placeholder) && ! is_callable($placeholder)) {
  285.             throw InvalidArgumentException::invalidPlaceholder($name);
  286.         }
  288.         $this->placeholders[$name] = $placeholder;
  289.     }
  291.     /**
  292.      * Sets the base template used to create proxy classes.
  293.      *
  294.      * @param string $proxyClassTemplate
  295.      */
  296.     public function setProxyClassTemplate($proxyClassTemplate)
  297.     {
  298.         $this->proxyClassTemplate = (string) $proxyClassTemplate;
  299.     }
  301.     /**
  302.      * Generates a proxy class file.
  303.      *
  304.      * @param ClassMetadata $class    Metadata for the original class.
  305.      * @param string|bool   $fileName Filename (full path) for the generated class. If none is given, eval() is used.
  306.      *
  307.      * @throws InvalidArgumentException
  308.      * @throws UnexpectedValueException
  309.      */
  310.     public function generateProxyClass(ClassMetadata $class, $fileName = false)
  311.     {
  312.         $this->verifyClassCanBeProxied($class);
  314.         preg_match_all('(<([a-zA-Z]+)>)', $this->proxyClassTemplate, $placeholderMatches);
  316.         $placeholderMatches = array_combine($placeholderMatches[0], $placeholderMatches[1]);
  317.         $placeholders       = [];
  319.         foreach ($placeholderMatches as $placeholder => $name) {
  320.             $placeholders[$placeholder] = $this->placeholders[$name] ?? [$this, 'generate' . $name];
  321.         }
  323.         foreach ($placeholders as & $placeholder) {
  324.             if (! is_callable($placeholder)) {
  325.                 continue;
  326.             }
  328.             $placeholder = call_user_func($placeholder, $class);
  329.         }
  331.         $proxyCode = strtr($this->proxyClassTemplate, $placeholders);
  333.         if (! $fileName) {
  334.             $proxyClassName = $this->generateNamespace($class) . '\\' . $this->generateProxyShortClassName($class);
  336.             if (! class_exists($proxyClassName)) {
  337.                 eval(substr($proxyCode, 5));
  338.             }
  340.             return;
  341.         }
  343.         $parentDirectory = dirname($fileName);
  345.         if (! is_dir($parentDirectory) && (@mkdir($parentDirectory, 0775, true) === false)) {
  346.             throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  347.         }
  349.         if (! is_writable($parentDirectory)) {
  350.             throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  351.         }
  353.         $tmpFileName = $fileName . '.' . bin2hex(random_bytes(12));
  355.         file_put_contents($tmpFileName, $proxyCode);
  356.         @chmod($tmpFileName, 0664);
  357.         rename($tmpFileName, $fileName);
  358.     }
  360.     /** @throws InvalidArgumentException */
  361.     private function verifyClassCanBeProxied(ClassMetadata $class)
  362.     {
  363.         if ($class->getReflectionClass()->isFinal()) {
  364.             throw InvalidArgumentException::classMustNotBeFinal($class->getName());
  365.         }
  367.         if ($class->getReflectionClass()->isAbstract()) {
  368.             throw InvalidArgumentException::classMustNotBeAbstract($class->getName());
  369.         }
  371.         if (PHP_VERSION_ID >= 80200 && $class->getReflectionClass()->isReadOnly()) {
  372.             throw InvalidArgumentException::classMustNotBeReadOnly($class->getName());
  373.         }
  374.     }
  376.     /**
  377.      * Generates the proxy short class name to be used in the template.
  378.      *
  379.      * @return string
  380.      */
  381.     private function generateProxyShortClassName(ClassMetadata $class)
  382.     {
  383.         $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  384.         $parts          = explode('\\', strrev($proxyClassName), 2);
  386.         return strrev($parts[0]);
  387.     }
  389.     /**
  390.      * Generates the proxy namespace.
  391.      *
  392.      * @return string
  393.      */
  394.     private function generateNamespace(ClassMetadata $class)
  395.     {
  396.         $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  397.         $parts          = explode('\\', strrev($proxyClassName), 2);
  399.         return strrev($parts[1]);
  400.     }
  402.     /**
  403.      * Enums must have a use statement when used as public property defaults.
  404.      */
  405.     public function generateEnumUseStatements(ClassMetadata $class): string
  406.     {
  407.         if (PHP_VERSION_ID < 80100) {
  408.             return "\n";
  409.         }
  411.         $defaultProperties          = $class->getReflectionClass()->getDefaultProperties();
  412.         $lazyLoadedPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  413.         $enumClasses                = [];
  415.         foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  416.             $name = $property->getName();
  418.             if (! in_array($name, $lazyLoadedPublicProperties, true)) {
  419.                 continue;
  420.             }
  422.             if (array_key_exists($name, $defaultProperties) && $defaultProperties[$name] instanceof BackedEnum) {
  423.                 $enumClassNameParts = explode('\\', get_class($defaultProperties[$name]));
  424.                 $enumClasses[]      = $enumClassNameParts[0];
  425.             }
  426.         }
  428.         return implode(
  429.             "\n",
  430.             array_map(
  431.                 static function ($className) {
  432.                     return 'use ' . $className . ';';
  433.                 },
  434.                 array_unique($enumClasses)
  435.             )
  436.         ) . "\n";
  437.     }
  439.     /**
  440.      * Generates the original class name.
  441.      *
  442.      * @return string
  443.      */
  444.     private function generateClassName(ClassMetadata $class)
  445.     {
  446.         return ltrim($class->getName(), '\\');
  447.     }
  449.     /**
  450.      * Generates the array representation of lazy loaded public properties and their default values.
  451.      *
  452.      * @return string
  453.      */
  454.     private function generateLazyPropertiesNames(ClassMetadata $class)
  455.     {
  456.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  457.         $values               = [];
  459.         foreach ($lazyPublicProperties as $name) {
  460.             $values[$name] = null;
  461.         }
  463.         return var_export($values, true);
  464.     }
  466.     /**
  467.      * Generates the array representation of lazy loaded public properties names.
  468.      *
  469.      * @return string
  470.      */
  471.     private function generateLazyPropertiesDefaults(ClassMetadata $class)
  472.     {
  473.         return var_export($this->getLazyLoadedPublicProperties($class), true);
  474.     }
  476.     /**
  477.      * Generates the constructor code (un-setting public lazy loaded properties, setting identifier field values).
  478.      *
  479.      * @return string
  480.      */
  481.     private function generateConstructorImpl(ClassMetadata $class)
  482.     {
  483.         $constructorImpl = <<<'EOT'
  484.     public function __construct(?\Closure $initializer = null, ?\Closure $cloner = null)
  485.     {
  487. EOT;
  489.         $toUnset = array_map(static function (string $name): string {
  490.             return '$this->' . $name;
  491.         }, $this->getLazyLoadedPublicPropertiesNames($class));
  493.         return $constructorImpl . ($toUnset === [] ? '' : '        unset(' . implode(', ', $toUnset) . ");\n")
  494.             . <<<'EOT'
  496.         $this->__initializer__ = $initializer;
  497.         $this->__cloner__      = $cloner;
  498.     }
  499. EOT;
  500.     }
  502.     /**
  503.      * Generates the magic getter invoked when lazy loaded public properties are requested.
  504.      *
  505.      * @return string
  506.      */
  507.     private function generateMagicGet(ClassMetadata $class)
  508.     {
  509.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  510.         $reflectionClass      = $class->getReflectionClass();
  511.         $hasParentGet         = false;
  512.         $returnReference      = '';
  513.         $inheritDoc           = '';
  514.         $name                 = '$name';
  515.         $parametersString     = '$name';
  516.         $returnTypeHint       = null;
  518.         if ($reflectionClass->hasMethod('__get')) {
  519.             $hasParentGet     = true;
  520.             $inheritDoc       = '{@inheritDoc}';
  521.             $methodReflection = $reflectionClass->getMethod('__get');
  523.             if ($methodReflection->returnsReference()) {
  524.                 $returnReference = '& ';
  525.             }
  527.             $methodParameters = $methodReflection->getParameters();
  528.             $name             = '$' . $methodParameters[0]->getName();
  530.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name']);
  531.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  532.         }
  534.         if (empty($lazyPublicProperties) && ! $hasParentGet) {
  535.             return '';
  536.         }
  538.         $magicGet = <<<EOT
  539.     /**
  540.      * $inheritDoc
  541.      * @param string \$name
  542.      */
  543.     public function {$returnReference}__get($parametersString)$returnTypeHint
  544.     {
  546. EOT;
  548.         if (! empty($lazyPublicProperties)) {
  549.             $magicGet .= <<<'EOT'
  550.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  551.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  552. EOT;
  554.             if ($returnTypeHint === ': void') {
  555.                 $magicGet .= "\n            return;";
  556.             } else {
  557.                 $magicGet .= "\n            return \$this->\$name;";
  558.             }
  560.             $magicGet .= <<<'EOT'
  562.         }
  565. EOT;
  566.         }
  568.         if ($hasParentGet) {
  569.             $magicGet .= <<<'EOT'
  570.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  571. EOT;
  573.             if ($returnTypeHint === ': void') {
  574.                 $magicGet .= <<<'EOT'
  576.         parent::__get($name);
  577.         return;
  578. EOT;
  579.             } elseif ($returnTypeHint === ': never') {
  580.                 $magicGet .= <<<'EOT'
  582.         parent::__get($name);
  583. EOT;
  584.             } else {
  585.                 $magicGet .= <<<'EOT'
  587.         return parent::__get($name);
  588. EOT;
  589.             }
  590.         } else {
  591.             $magicGet .= sprintf(<<<EOT
  592.         trigger_error(sprintf('Undefined property: %%s::$%%s', __CLASS__, %s), E_USER_NOTICE);
  594. EOT
  595.                 , $name);
  596.         }
  598.         return $magicGet . "\n    }";
  599.     }
  601.     /**
  602.      * Generates the magic setter (currently unused).
  603.      *
  604.      * @return string
  605.      */
  606.     private function generateMagicSet(ClassMetadata $class)
  607.     {
  608.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  609.         $reflectionClass      = $class->getReflectionClass();
  610.         $hasParentSet         = false;
  611.         $inheritDoc           = '';
  612.         $parametersString     = '$name, $value';
  613.         $returnTypeHint       = null;
  615.         if ($reflectionClass->hasMethod('__set')) {
  616.             $hasParentSet     = true;
  617.             $inheritDoc       = '{@inheritDoc}';
  618.             $methodReflection = $reflectionClass->getMethod('__set');
  620.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name', 'value']);
  621.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  622.         }
  624.         if (empty($lazyPublicProperties) && ! $hasParentSet) {
  625.             return '';
  626.         }
  628.         $magicSet = <<<EOT
  629.     /**
  630.      * $inheritDoc
  631.      * @param string \$name
  632.      * @param mixed  \$value
  633.      */
  634.     public function __set($parametersString)$returnTypeHint
  635.     {
  637. EOT;
  639.         if (! empty($lazyPublicProperties)) {
  640.             $magicSet .= <<<'EOT'
  641.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  642.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  644.             $this->$name = $value;
  646.             return;
  647.         }
  650. EOT;
  651.         }
  653.         if ($hasParentSet) {
  654.             $magicSet .= <<<'EOT'
  655.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  656. EOT;
  658.             if ($returnTypeHint === ': void') {
  659.                 $magicSet .= <<<'EOT'
  661.         parent::__set($name, $value);
  662.         return;
  663. EOT;
  664.             } elseif ($returnTypeHint === ': never') {
  665.                 $magicSet .= <<<'EOT'
  667.         parent::__set($name, $value);
  668. EOT;
  669.             } else {
  670.                 $magicSet .= <<<'EOT'
  672.         return parent::__set($name, $value);
  673. EOT;
  674.             }
  675.         } else {
  676.             $magicSet .= '        $this->$name = $value;';
  677.         }
  679.         return $magicSet . "\n    }";
  680.     }
  682.     /**
  683.      * Generates the magic issetter invoked when lazy loaded public properties are checked against isset().
  684.      *
  685.      * @return string
  686.      */
  687.     private function generateMagicIsset(ClassMetadata $class)
  688.     {
  689.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  690.         $hasParentIsset       = $class->getReflectionClass()->hasMethod('__isset');
  691.         $parametersString     = '$name';
  692.         $returnTypeHint       = null;
  694.         if ($hasParentIsset) {
  695.             $methodReflection = $class->getReflectionClass()->getMethod('__isset');
  696.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name']);
  697.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  698.         }
  700.         if (empty($lazyPublicProperties) && ! $hasParentIsset) {
  701.             return '';
  702.         }
  704.         $inheritDoc = $hasParentIsset ? '{@inheritDoc}' : '';
  705.         $magicIsset = <<<EOT
  706.     /**
  707.      * $inheritDoc
  708.      * @param  string \$name
  709.      * @return boolean
  710.      */
  711.     public function __isset($parametersString)$returnTypeHint
  712.     {
  714. EOT;
  716.         if (! empty($lazyPublicProperties)) {
  717.             $magicIsset .= <<<'EOT'
  718.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  719.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  721.             return isset($this->$name);
  722.         }
  725. EOT;
  726.         }
  728.         if ($hasParentIsset) {
  729.             $magicIsset .= <<<'EOT'
  730.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  732.         return parent::__isset($name);
  733. EOT;
  734.         } else {
  735.             $magicIsset .= '        return false;';
  736.         }
  738.         return $magicIsset . "\n    }";
  739.     }
  741.     /**
  742.      * Generates implementation for the `__sleep` method of proxies.
  743.      *
  744.      * @return string
  745.      */
  746.     private function generateSleepImpl(ClassMetadata $class)
  747.     {
  748.         $reflectionClass = $class->getReflectionClass();
  750.         $hasParentSleep = $reflectionClass->hasMethod('__sleep');
  751.         $inheritDoc     = $hasParentSleep ? '{@inheritDoc}' : '';
  752.         $returnTypeHint = $hasParentSleep ? $this->getMethodReturnType($reflectionClass->getMethod('__sleep')) : '';
  753.         $sleepImpl      = <<<EOT
  754.     /**
  755.      * $inheritDoc
  756.      * @return array
  757.      */
  758.     public function __sleep()$returnTypeHint
  759.     {
  761. EOT;
  763.         if ($hasParentSleep) {
  764.             return $sleepImpl . <<<'EOT'
  765.         $properties = array_merge(['__isInitialized__'], parent::__sleep());
  767.         if ($this->__isInitialized__) {
  768.             $properties = array_diff($properties, array_keys(self::$lazyPropertiesNames));
  769.         }
  771.         return $properties;
  772.     }
  773. EOT;
  774.         }
  776.         $allProperties = ['__isInitialized__'];
  778.         foreach ($class->getReflectionClass()->getProperties() as $prop) {
  779.             assert($prop instanceof ReflectionProperty);
  780.             if ($prop->isStatic()) {
  781.                 continue;
  782.             }
  784.             $allProperties[] = $prop->isPrivate()
  785.                 ? "\0" . $prop->getDeclaringClass()->getName() . "\0" . $prop->getName()
  786.                 : $prop->getName();
  787.         }
  789.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  790.         $protectedProperties  = array_diff($allProperties, $lazyPublicProperties);
  792.         foreach ($allProperties as &$property) {
  793.             $property = var_export($property, true);
  794.         }
  796.         foreach ($protectedProperties as &$property) {
  797.             $property = var_export($property, true);
  798.         }
  800.         $allProperties       = implode(', ', $allProperties);
  801.         $protectedProperties = implode(', ', $protectedProperties);
  803.         return $sleepImpl . <<<EOT
  804.         if (\$this->__isInitialized__) {
  805.             return [$allProperties];
  806.         }
  808.         return [$protectedProperties];
  809.     }
  810. EOT;
  811.     }
  813.     /**
  814.      * Generates implementation for the `__wakeup` method of proxies.
  815.      *
  816.      * @return string
  817.      */
  818.     private function generateWakeupImpl(ClassMetadata $class)
  819.     {
  820.         $reflectionClass = $class->getReflectionClass();
  822.         $hasParentWakeup = $reflectionClass->hasMethod('__wakeup');
  824.         $unsetPublicProperties = [];
  825.         foreach ($this->getLazyLoadedPublicPropertiesNames($class) as $lazyPublicProperty) {
  826.             $unsetPublicProperties[] = '$this->' . $lazyPublicProperty;
  827.         }
  829.         $shortName      = $this->generateProxyShortClassName($class);
  830.         $inheritDoc     = $hasParentWakeup ? '{@inheritDoc}' : '';
  831.         $returnTypeHint = $hasParentWakeup ? $this->getMethodReturnType($reflectionClass->getMethod('__wakeup')) : '';
  832.         $wakeupImpl     = <<<EOT
  833.     /**
  834.      * $inheritDoc
  835.      */
  836.     public function __wakeup()$returnTypeHint
  837.     {
  838.         if ( ! \$this->__isInitialized__) {
  839.             \$this->__initializer__ = function ($shortName \$proxy) {
  840.                 \$proxy->__setInitializer(null);
  841.                 \$proxy->__setCloner(null);
  843.                 \$existingProperties = get_object_vars(\$proxy);
  845.                 foreach (\$proxy::\$lazyPropertiesDefaults as \$property => \$defaultValue) {
  846.                     if ( ! array_key_exists(\$property, \$existingProperties)) {
  847.                         \$proxy->\$property = \$defaultValue;
  848.                     }
  849.                 }
  850.             };
  852. EOT;
  854.         if (! empty($unsetPublicProperties)) {
  855.             $wakeupImpl .= "\n            unset(" . implode(', ', $unsetPublicProperties) . ');';
  856.         }
  858.         $wakeupImpl .= "\n        }";
  860.         if ($hasParentWakeup) {
  861.             $wakeupImpl .= "\n        parent::__wakeup();";
  862.         }
  864.         $wakeupImpl .= "\n    }";
  866.         return $wakeupImpl;
  867.     }
  869.     /**
  870.      * Generates implementation for the `__clone` method of proxies.
  871.      *
  872.      * @return string
  873.      */
  874.     private function generateCloneImpl(ClassMetadata $class)
  875.     {
  876.         $reflectionClass = $class->getReflectionClass();
  877.         $hasParentClone  = $reflectionClass->hasMethod('__clone');
  878.         $returnTypeHint  = $hasParentClone ? $this->getMethodReturnType($reflectionClass->getMethod('__clone')) : '';
  879.         $inheritDoc      = $hasParentClone ? '{@inheritDoc}' : '';
  880.         $callParentClone = $hasParentClone ? "\n        parent::__clone();\n" : '';
  882.         return <<<EOT
  883.     /**
  884.      * $inheritDoc
  885.      */
  886.     public function __clone()$returnTypeHint
  887.     {
  888.         \$this->__cloner__ && \$this->__cloner__->__invoke(\$this, '__clone', []);
  889. $callParentClone    }
  890. EOT;
  891.     }
  893.     /**
  894.      * Generates decorated methods by picking those available in the parent class.
  895.      *
  896.      * @return string
  897.      */
  898.     private function generateMethods(ClassMetadata $class)
  899.     {
  900.         $methods           = '';
  901.         $methodNames       = [];
  902.         $reflectionMethods = $class->getReflectionClass()->getMethods(ReflectionMethod::IS_PUBLIC);
  903.         $skippedMethods    = [
  904.             '__sleep'   => true,
  905.             '__clone'   => true,
  906.             '__wakeup'  => true,
  907.             '__get'     => true,
  908.             '__set'     => true,
  909.             '__isset'   => true,
  910.         ];
  912.         foreach ($reflectionMethods as $method) {
  913.             $name = $method->getName();
  915.             if (
  916.                 $method->isConstructor() ||
  917.                 isset($skippedMethods[strtolower($name)]) ||
  918.                 isset($methodNames[$name]) ||
  919.                 $method->isFinal() ||
  920.                 $method->isStatic() ||
  921.                 ( ! $method->isPublic())
  922.             ) {
  923.                 continue;
  924.             }
  926.             $methodNames[$name] = true;
  927.             $methods           .= "\n    /**\n"
  928.                 . "     * {@inheritDoc}\n"
  929.                 . "     */\n"
  930.                 . '    public function ';
  932.             if ($method->returnsReference()) {
  933.                 $methods .= '&';
  934.             }
  936.             $methods .= $name . '(' . $this->buildParametersString($method->getParameters()) . ')';
  937.             $methods .= $this->getMethodReturnType($method);
  938.             $methods .= "\n" . '    {' . "\n";
  940.             if ($this->isShortIdentifierGetter($method, $class)) {
  941.                 $identifier = lcfirst(substr($name, 3));
  942.                 $fieldType  = $class->getTypeOfField($identifier);
  943.                 $cast       = in_array($fieldType, ['integer', 'smallint']) ? '(int) ' : '';
  945.                 $methods .= '        if ($this->__isInitialized__ === false) {' . "\n";
  946.                 $methods .= '            ';
  947.                 $methods .= $this->shouldProxiedMethodReturn($method) ? 'return ' : '';
  948.                 $methods .= $cast . ' parent::' . $method->getName() . "();\n";
  949.                 $methods .= '        }' . "\n\n";
  950.             }
  952.             $invokeParamsString = implode(', ', $this->getParameterNamesForInvoke($method->getParameters()));
  953.             $callParamsString   = implode(', ', $this->getParameterNamesForParentCall($method->getParameters()));
  955.             $methods .= "\n        \$this->__initializer__ "
  956.                 . '&& $this->__initializer__->__invoke($this, ' . var_export($name, true)
  957.                 . ', [' . $invokeParamsString . ']);'
  958.                 . "\n\n        "
  959.                 . ($this->shouldProxiedMethodReturn($method) ? 'return ' : '')
  960.                 . 'parent::' . $name . '(' . $callParamsString . ');'
  961.                 . "\n" . '    }' . "\n";
  962.         }
  964.         return $methods;
  965.     }
  967.     /**
  968.      * Generates the Proxy file name.
  969.      *
  970.      * @param string $className
  971.      * @param string $baseDirectory Optional base directory for proxy file name generation.
  972.      *                              If not specified, the directory configured on the Configuration of the
  973.      *                              EntityManager will be used by this factory.
  974.      * @psalm-param class-string $className
  975.      *
  976.      * @return string
  977.      */
  978.     public function getProxyFileName($className, $baseDirectory = null)
  979.     {
  980.         $baseDirectory = $baseDirectory ?: $this->proxyDirectory;
  982.         return rtrim($baseDirectory, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . Proxy::MARKER
  983.             . str_replace('\\', '', $className) . '.php';
  984.     }
  986.     /**
  987.      * Checks if the method is a short identifier getter.
  988.      *
  989.      * What does this mean? For proxy objects the identifier is already known,
  990.      * however accessing the getter for this identifier usually triggers the
  991.      * lazy loading, leading to a query that may not be necessary if only the
  992.      * ID is interesting for the userland code (for example in views that
  993.      * generate links to the entity, but do not display anything else).
  994.      *
  995.      * @param ReflectionMethod $method
  996.      *
  997.      * @return bool
  998.      */
  999.     private function isShortIdentifierGetter($method, ClassMetadata $class)
  1000.     {
  1001.         $identifier = lcfirst(substr($method->getName(), 3));
  1002.         $startLine  = $method->getStartLine();
  1003.         $endLine    = $method->getEndLine();
  1004.         $cheapCheck = $method->getNumberOfParameters() === 0
  1005.             && substr($method->getName(), 0, 3) === 'get'
  1006.             && in_array($identifier, $class->getIdentifier(), true)
  1007.             && $class->hasField($identifier)
  1008.             && ($endLine - $startLine <= 4);
  1010.         if ($cheapCheck) {
  1011.             $code = file($method->getFileName());
  1012.             $code = trim(implode(' ', array_slice($code, $startLine - 1, $endLine - $startLine + 1)));
  1014.             $pattern = sprintf(self::PATTERN_MATCH_ID_METHOD, $method->getName(), $identifier);
  1016.             if (preg_match($pattern, $code)) {
  1017.                 return true;
  1018.             }
  1019.         }
  1021.         return false;
  1022.     }
  1024.     /**
  1025.      * Generates the list of public properties to be lazy loaded.
  1026.      *
  1027.      * @return array<int, string>
  1028.      */
  1029.     private function getLazyLoadedPublicPropertiesNames(ClassMetadata $class): array
  1030.     {
  1031.         $properties = [];
  1033.         foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  1034.             $name = $property->getName();
  1036.             if ((! $class->hasField($name) && ! $class->hasAssociation($name)) || $class->isIdentifier($name)) {
  1037.                 continue;
  1038.             }
  1040.             $properties[] = $name;
  1041.         }
  1043.         return $properties;
  1044.     }
  1046.     /**
  1047.      * Generates the list of default values of public properties.
  1048.      *
  1049.      * @return mixed[]
  1050.      */
  1051.     private function getLazyLoadedPublicProperties(ClassMetadata $class)
  1052.     {
  1053.         $defaultProperties          = $class->getReflectionClass()->getDefaultProperties();
  1054.         $lazyLoadedPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  1055.         $defaultValues              = [];
  1057.         foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  1058.             $name = $property->getName();
  1060.             if (! in_array($name, $lazyLoadedPublicProperties, true)) {
  1061.                 continue;
  1062.             }
  1064.             if (array_key_exists($name, $defaultProperties)) {
  1065.                 $defaultValues[$name] = $defaultProperties[$name];
  1066.             } elseif (method_exists($property, 'getType')) {
  1067.                 $propertyType = $property->getType();
  1068.                 if ($propertyType !== null && $propertyType->allowsNull()) {
  1069.                     $defaultValues[$name] = null;
  1070.                 }
  1071.             }
  1072.         }
  1074.         return $defaultValues;
  1075.     }
  1077.     /**
  1078.      * @param ReflectionParameter[] $parameters
  1079.      * @param string[]              $renameParameters
  1080.      *
  1081.      * @return string
  1082.      */
  1083.     private function buildParametersString(array $parameters, array $renameParameters = [])
  1084.     {
  1085.         $parameterDefinitions = [];
  1087.         $i = -1;
  1088.         foreach ($parameters as $param) {
  1089.             assert($param instanceof ReflectionParameter);
  1090.             $i++;
  1091.             $parameterDefinition = '';
  1092.             $parameterType       = $this->getParameterType($param);
  1094.             if ($parameterType !== null) {
  1095.                 $parameterDefinition .= $parameterType . ' ';
  1096.             }
  1098.             if ($param->isPassedByReference()) {
  1099.                 $parameterDefinition .= '&';
  1100.             }
  1102.             if ($param->isVariadic()) {
  1103.                 $parameterDefinition .= '...';
  1104.             }
  1106.             $parameterDefinition .= '$' . ($renameParameters ? $renameParameters[$i] : $param->getName());
  1107.             $parameterDefinition .= $this->getParameterDefaultValue($param);
  1109.             $parameterDefinitions[] = $parameterDefinition;
  1110.         }
  1112.         return implode(', ', $parameterDefinitions);
  1113.     }
  1115.     /** @return string|null */
  1116.     private function getParameterType(ReflectionParameter $parameter)
  1117.     {
  1118.         if (! $parameter->hasType()) {
  1119.             return null;
  1120.         }
  1122.         $declaringFunction = $parameter->getDeclaringFunction();
  1124.         assert($declaringFunction instanceof ReflectionMethod);
  1126.         return $this->formatType($parameter->getType(), $declaringFunction, $parameter);
  1127.     }
  1129.     /** @return string */
  1130.     private function getParameterDefaultValue(ReflectionParameter $parameter)
  1131.     {
  1132.         if (! $parameter->isDefaultValueAvailable()) {
  1133.             return '';
  1134.         }
  1136.         if (PHP_VERSION_ID < 80100 || is_scalar($parameter->getDefaultValue())) {
  1137.             return ' = ' . var_export($parameter->getDefaultValue(), true);
  1138.         }
  1140.         $value = rtrim(substr(explode('$' . $parameter->getName() . ' = ', (string) $parameter, 2)[1], 0, -2));
  1142.         if (strpos($value, '\\') !== false || strpos($value, '::') !== false) {
  1143.             $value = preg_split("/('(?:[^'\\\\]*+(?:\\\\.)*+)*+')/", $value, -1, PREG_SPLIT_DELIM_CAPTURE);
  1144.             foreach ($value as $i => $part) {
  1145.                 if ($i % 2 === 0) {
  1146.                     $value[$i] = preg_replace('/(?<![a-zA-Z0-9_\x7f-\xff\\\\])[a-zA-Z0-9_\x7f-\xff]++(?:\\\\[a-zA-Z0-9_\x7f-\xff]++|::)++/', '\\\\\0', $part);
  1147.                 }
  1148.             }
  1150.             $value = implode('', $value);
  1151.         }
  1153.         return ' = ' . $value;
  1154.     }
  1156.     /**
  1157.      * @param ReflectionParameter[] $parameters
  1158.      *
  1159.      * @return string[]
  1160.      */
  1161.     private function getParameterNamesForInvoke(array $parameters)
  1162.     {
  1163.         return array_map(
  1164.             static function (ReflectionParameter $parameter) {
  1165.                 return '$' . $parameter->getName();
  1166.             },
  1167.             $parameters
  1168.         );
  1169.     }
  1171.     /**
  1172.      * @param ReflectionParameter[] $parameters
  1173.      *
  1174.      * @return string[]
  1175.      */
  1176.     private function getParameterNamesForParentCall(array $parameters)
  1177.     {
  1178.         return array_map(
  1179.             static function (ReflectionParameter $parameter) {
  1180.                 $name = '';
  1182.                 if ($parameter->isVariadic()) {
  1183.                     $name .= '...';
  1184.                 }
  1186.                 $name .= '$' . $parameter->getName();
  1188.                 return $name;
  1189.             },
  1190.             $parameters
  1191.         );
  1192.     }
  1194.     /** @return string */
  1195.     private function getMethodReturnType(ReflectionMethod $method)
  1196.     {
  1197.         if (! $method->hasReturnType()) {
  1198.             return '';
  1199.         }
  1201.         return ': ' . $this->formatType($method->getReturnType(), $method);
  1202.     }
  1204.     /** @return bool */
  1205.     private function shouldProxiedMethodReturn(ReflectionMethod $method)
  1206.     {
  1207.         if (! $method->hasReturnType()) {
  1208.             return true;
  1209.         }
  1211.         return ! in_array(
  1212.             strtolower($this->formatType($method->getReturnType(), $method)),
  1213.             ['void', 'never'],
  1214.             true
  1215.         );
  1216.     }
  1218.     /** @return string */
  1219.     private function formatType(
  1220.         ReflectionType $type,
  1221.         ReflectionMethod $method,
  1222.         ?ReflectionParameter $parameter = null
  1223.     ) {
  1224.         if ($type instanceof ReflectionUnionType) {
  1225.             return implode('|', array_map(
  1226.                 function (ReflectionType $unionedType) use ($method, $parameter) {
  1227.                     if ($unionedType instanceof ReflectionIntersectionType) {
  1228.                         return '(' . $this->formatType($unionedType, $method, $parameter) . ')';
  1229.                     }
  1231.                     return $this->formatType($unionedType, $method, $parameter);
  1232.                 },
  1233.                 $type->getTypes()
  1234.             ));
  1235.         }
  1237.         if ($type instanceof ReflectionIntersectionType) {
  1238.             return implode('&', array_map(
  1239.                 function (ReflectionType $intersectedType) use ($method, $parameter) {
  1240.                     return $this->formatType($intersectedType, $method, $parameter);
  1241.                 },
  1242.                 $type->getTypes()
  1243.             ));
  1244.         }
  1246.         assert($type instanceof ReflectionNamedType);
  1248.         $name      = $type->getName();
  1249.         $nameLower = strtolower($name);
  1251.         if ($nameLower === 'static') {
  1252.             $name = 'static';
  1253.         }
  1255.         if ($nameLower === 'self') {
  1256.             $name = $method->getDeclaringClass()->getName();
  1257.         }
  1259.         if ($nameLower === 'parent') {
  1260.             $name = $method->getDeclaringClass()->getParentClass()->getName();
  1261.         }
  1263.         if (! $type->isBuiltin() && ! class_exists($name) && ! interface_exists($name) && $name !== 'static') {
  1264.             if ($parameter !== null) {
  1265.                 throw UnexpectedValueException::invalidParameterTypeHint(
  1266.                     $method->getDeclaringClass()->getName(),
  1267.                     $method->getName(),
  1268.                     $parameter->getName()
  1269.                 );
  1270.             }
  1272.             throw UnexpectedValueException::invalidReturnTypeHint(
  1273.                 $method->getDeclaringClass()->getName(),
  1274.                 $method->getName()
  1275.             );
  1276.         }
  1278.         if (! $type->isBuiltin() && $name !== 'static') {
  1279.             $name = '\\' . $name;
  1280.         }
  1282.         if (
  1283.             $type->allowsNull()
  1284.             && ! in_array($name, ['mixed', 'null'], true)
  1285.             && ($parameter === null || ! $parameter->isDefaultValueAvailable() || $parameter->getDefaultValue() !== null)
  1286.         ) {
  1287.             $name = '?' . $name;
  1288.         }
  1290.         return $name;
  1291.     }
  1292. }