vendor/doctrine/common/lib/Doctrine/Common/Proxy/ProxyGenerator.php line 1159

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 call_user_func;
  26. use function chmod;
  27. use function class_exists;
  28. use function dirname;
  29. use function explode;
  30. use function file;
  31. use function file_put_contents;
  32. use function get_class;
  33. use function implode;
  34. use function in_array;
  35. use function interface_exists;
  36. use function is_callable;
  37. use function is_dir;
  38. use function is_string;
  39. use function is_writable;
  40. use function lcfirst;
  41. use function ltrim;
  42. use function method_exists;
  43. use function mkdir;
  44. use function preg_match;
  45. use function preg_match_all;
  46. use function rename;
  47. use function rtrim;
  48. use function sprintf;
  49. use function str_replace;
  50. use function strrev;
  51. use function strtolower;
  52. use function strtr;
  53. use function substr;
  54. use function trim;
  55. use function uniqid;
  56. use function var_export;
  58. use const DIRECTORY_SEPARATOR;
  59. use const PHP_VERSION_ID;
  61. /**
  62.  * This factory is used to generate proxy classes.
  63.  * It builds proxies from given parameters, a template and class metadata.
  64.  */
  65. class ProxyGenerator
  66. {
  67.     /**
  68.      * Used to match very simple id methods that don't need
  69.      * to be decorated since the identifier is known.
  70.      */
  71.     public const PATTERN_MATCH_ID_METHOD = '((public\s+)?(function\s+%s\s*\(\)\s*)\s*(?::\s*\??\s*\\\\?[a-z_\x7f-\xff][\w\x7f-\xff]*(?:\\\\[a-z_\x7f-\xff][\w\x7f-\xff]*)*\s*)?{\s*return\s*\$this->%s;\s*})i';
  73.     /**
  74.      * The namespace that contains all proxy classes.
  75.      *
  76.      * @var string
  77.      */
  78.     private $proxyNamespace;
  80.     /**
  81.      * The directory that contains all proxy classes.
  82.      *
  83.      * @var string
  84.      */
  85.     private $proxyDirectory;
  87.     /**
  88.      * Map of callables used to fill in placeholders set in the template.
  89.      *
  90.      * @var string[]|callable[]
  91.      */
  92.     protected $placeholders = [
  93.         'baseProxyInterface'   => Proxy::class,
  94.         'additionalProperties' => '',
  95.     ];
  97.     /**
  98.      * Template used as a blueprint to generate proxies.
  99.      *
  100.      * @var string
  101.      */
  102.     protected $proxyClassTemplate = '<?php
  104. namespace <namespace>;
  105. <enumUseStatements>
  106. /**
  107.  * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE\'S PROXY GENERATOR
  108.  */
  109. class <proxyShortClassName> extends \<className> implements \<baseProxyInterface>
  110. {
  111.     /**
  112.      * @var \Closure the callback responsible for loading properties in the proxy object. This callback is called with
  113.      *      three parameters, being respectively the proxy object to be initialized, the method that triggered the
  114.      *      initialization process and an array of ordered parameters that were passed to that method.
  115.      *
  116.      * @see \Doctrine\Common\Proxy\Proxy::__setInitializer
  117.      */
  118.     public $__initializer__;
  120.     /**
  121.      * @var \Closure the callback responsible of loading properties that need to be copied in the cloned object
  122.      *
  123.      * @see \Doctrine\Common\Proxy\Proxy::__setCloner
  124.      */
  125.     public $__cloner__;
  127.     /**
  128.      * @var boolean flag indicating if this object was already initialized
  129.      *
  130.      * @see \Doctrine\Persistence\Proxy::__isInitialized
  131.      */
  132.     public $__isInitialized__ = false;
  134.     /**
  135.      * @var array<string, null> properties to be lazy loaded, indexed by property name
  136.      */
  137.     public static $lazyPropertiesNames = <lazyPropertiesNames>;
  139.     /**
  140.      * @var array<string, mixed> default values of properties to be lazy loaded, with keys being the property names
  141.      *
  142.      * @see \Doctrine\Common\Proxy\Proxy::__getLazyProperties
  143.      */
  144.     public static $lazyPropertiesDefaults = <lazyPropertiesDefaults>;
  146. <additionalProperties>
  148. <constructorImpl>
  150. <magicGet>
  152. <magicSet>
  154. <magicIsset>
  156. <sleepImpl>
  158. <wakeupImpl>
  160. <cloneImpl>
  162.     /**
  163.      * Forces initialization of the proxy
  164.      */
  165.     public function __load()
  166.     {
  167.         $this->__initializer__ && $this->__initializer__->__invoke($this, \'__load\', []);
  168.     }
  170.     /**
  171.      * {@inheritDoc}
  172.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  173.      */
  174.     public function __isInitialized()
  175.     {
  176.         return $this->__isInitialized__;
  177.     }
  179.     /**
  180.      * {@inheritDoc}
  181.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  182.      */
  183.     public function __setInitialized($initialized)
  184.     {
  185.         $this->__isInitialized__ = $initialized;
  186.     }
  188.     /**
  189.      * {@inheritDoc}
  190.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  191.      */
  192.     public function __setInitializer(\Closure $initializer = null)
  193.     {
  194.         $this->__initializer__ = $initializer;
  195.     }
  197.     /**
  198.      * {@inheritDoc}
  199.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  200.      */
  201.     public function __getInitializer()
  202.     {
  203.         return $this->__initializer__;
  204.     }
  206.     /**
  207.      * {@inheritDoc}
  208.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  209.      */
  210.     public function __setCloner(\Closure $cloner = null)
  211.     {
  212.         $this->__cloner__ = $cloner;
  213.     }
  215.     /**
  216.      * {@inheritDoc}
  217.      * @internal generated method: use only when explicitly handling proxy specific cloning logic
  218.      */
  219.     public function __getCloner()
  220.     {
  221.         return $this->__cloner__;
  222.     }
  224.     /**
  225.      * {@inheritDoc}
  226.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  227.      * @deprecated no longer in use - generated code now relies on internal components rather than generated public API
  228.      * @static
  229.      */
  230.     public function __getLazyProperties()
  231.     {
  232.         return self::$lazyPropertiesDefaults;
  233.     }
  235.     <methods>
  236. }
  237. ';
  239.     /**
  240.      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
  241.      * connected to the given <tt>EntityManager</tt>.
  242.      *
  243.      * @param string $proxyDirectory The directory to use for the proxy classes. It must exist.
  244.      * @param string $proxyNamespace The namespace to use for the proxy classes.
  245.      *
  246.      * @throws InvalidArgumentException
  247.      */
  248.     public function __construct($proxyDirectory, $proxyNamespace)
  249.     {
  250.         if (! $proxyDirectory) {
  251.             throw InvalidArgumentException::proxyDirectoryRequired();
  252.         }
  254.         if (! $proxyNamespace) {
  255.             throw InvalidArgumentException::proxyNamespaceRequired();
  256.         }
  258.         $this->proxyDirectory = $proxyDirectory;
  259.         $this->proxyNamespace = $proxyNamespace;
  260.     }
  262.     /**
  263.      * Sets a placeholder to be replaced in the template.
  264.      *
  265.      * @param string          $name
  266.      * @param string|callable $placeholder
  267.      *
  268.      * @throws InvalidArgumentException
  269.      */
  270.     public function setPlaceholder($name, $placeholder)
  271.     {
  272.         if (! is_string($placeholder) && ! is_callable($placeholder)) {
  273.             throw InvalidArgumentException::invalidPlaceholder($name);
  274.         }
  276.         $this->placeholders[$name] = $placeholder;
  277.     }
  279.     /**
  280.      * Sets the base template used to create proxy classes.
  281.      *
  282.      * @param string $proxyClassTemplate
  283.      */
  284.     public function setProxyClassTemplate($proxyClassTemplate)
  285.     {
  286.         $this->proxyClassTemplate = (string) $proxyClassTemplate;
  287.     }
  289.     /**
  290.      * Generates a proxy class file.
  291.      *
  292.      * @param ClassMetadata $class    Metadata for the original class.
  293.      * @param string|bool   $fileName Filename (full path) for the generated class. If none is given, eval() is used.
  294.      *
  295.      * @throws InvalidArgumentException
  296.      * @throws UnexpectedValueException
  297.      */
  298.     public function generateProxyClass(ClassMetadata $class, $fileName = false)
  299.     {
  300.         $this->verifyClassCanBeProxied($class);
  302.         preg_match_all('(<([a-zA-Z]+)>)', $this->proxyClassTemplate, $placeholderMatches);
  304.         $placeholderMatches = array_combine($placeholderMatches[0], $placeholderMatches[1]);
  305.         $placeholders       = [];
  307.         foreach ($placeholderMatches as $placeholder => $name) {
  308.             $placeholders[$placeholder] = $this->placeholders[$name] ?? [$this, 'generate' . $name];
  309.         }
  311.         foreach ($placeholders as & $placeholder) {
  312.             if (! is_callable($placeholder)) {
  313.                 continue;
  314.             }
  316.             $placeholder = call_user_func($placeholder, $class);
  317.         }
  319.         $proxyCode = strtr($this->proxyClassTemplate, $placeholders);
  321.         if (! $fileName) {
  322.             $proxyClassName = $this->generateNamespace($class) . '\\' . $this->generateProxyShortClassName($class);
  324.             if (! class_exists($proxyClassName)) {
  325.                 eval(substr($proxyCode, 5));
  326.             }
  328.             return;
  329.         }
  331.         $parentDirectory = dirname($fileName);
  333.         if (! is_dir($parentDirectory) && (@mkdir($parentDirectory, 0775, true) === false)) {
  334.             throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  335.         }
  337.         if (! is_writable($parentDirectory)) {
  338.             throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  339.         }
  341.         $tmpFileName = $fileName . '.' . uniqid('', true);
  343.         file_put_contents($tmpFileName, $proxyCode);
  344.         @chmod($tmpFileName, 0664);
  345.         rename($tmpFileName, $fileName);
  346.     }
  348.     /**
  349.      * @throws InvalidArgumentException
  350.      */
  351.     private function verifyClassCanBeProxied(ClassMetadata $class)
  352.     {
  353.         if ($class->getReflectionClass()->isFinal()) {
  354.             throw InvalidArgumentException::classMustNotBeFinal($class->getName());
  355.         }
  357.         if ($class->getReflectionClass()->isAbstract()) {
  358.             throw InvalidArgumentException::classMustNotBeAbstract($class->getName());
  359.         }
  360.     }
  362.     /**
  363.      * Generates the proxy short class name to be used in the template.
  364.      *
  365.      * @return string
  366.      */
  367.     private function generateProxyShortClassName(ClassMetadata $class)
  368.     {
  369.         $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  370.         $parts          = explode('\\', strrev($proxyClassName), 2);
  372.         return strrev($parts[0]);
  373.     }
  375.     /**
  376.      * Generates the proxy namespace.
  377.      *
  378.      * @return string
  379.      */
  380.     private function generateNamespace(ClassMetadata $class)
  381.     {
  382.         $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  383.         $parts          = explode('\\', strrev($proxyClassName), 2);
  385.         return strrev($parts[1]);
  386.     }
  388.     /**
  389.      * Enums must have a use statement when used as public property defaults.
  390.      */
  391.     public function generateEnumUseStatements(ClassMetadata $class): string
  392.     {
  393.         if (PHP_VERSION_ID < 80100) {
  394.             return "\n";
  395.         }
  397.         $defaultProperties          = $class->getReflectionClass()->getDefaultProperties();
  398.         $lazyLoadedPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  399.         $enumClasses                = [];
  401.         foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  402.             $name = $property->getName();
  404.             if (! in_array($name, $lazyLoadedPublicProperties, true)) {
  405.                 continue;
  406.             }
  408.             if (array_key_exists($name, $defaultProperties) && $defaultProperties[$name] instanceof BackedEnum) {
  409.                 $enumClassNameParts = explode('\\', get_class($defaultProperties[$name]));
  410.                 $enumClasses[]      = $enumClassNameParts[0];
  411.             }
  412.         }
  414.         return implode(
  415.             "\n",
  416.             array_map(
  417.                 static function ($className) {
  418.                     return 'use ' . $className . ';';
  419.                 },
  420.                 array_unique($enumClasses)
  421.             )
  422.         ) . "\n";
  423.     }
  425.     /**
  426.      * Generates the original class name.
  427.      *
  428.      * @return string
  429.      */
  430.     private function generateClassName(ClassMetadata $class)
  431.     {
  432.         return ltrim($class->getName(), '\\');
  433.     }
  435.     /**
  436.      * Generates the array representation of lazy loaded public properties and their default values.
  437.      *
  438.      * @return string
  439.      */
  440.     private function generateLazyPropertiesNames(ClassMetadata $class)
  441.     {
  442.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  443.         $values               = [];
  445.         foreach ($lazyPublicProperties as $name) {
  446.             $values[$name] = null;
  447.         }
  449.         return var_export($values, true);
  450.     }
  452.     /**
  453.      * Generates the array representation of lazy loaded public properties names.
  454.      *
  455.      * @return string
  456.      */
  457.     private function generateLazyPropertiesDefaults(ClassMetadata $class)
  458.     {
  459.         return var_export($this->getLazyLoadedPublicProperties($class), true);
  460.     }
  462.     /**
  463.      * Generates the constructor code (un-setting public lazy loaded properties, setting identifier field values).
  464.      *
  465.      * @return string
  466.      */
  467.     private function generateConstructorImpl(ClassMetadata $class)
  468.     {
  469.         $constructorImpl = <<<'EOT'
  470.     public function __construct(?\Closure $initializer = null, ?\Closure $cloner = null)
  471.     {
  473. EOT;
  475.         $toUnset = array_map(static function (string $name): string {
  476.             return '$this->' . $name;
  477.         }, $this->getLazyLoadedPublicPropertiesNames($class));
  479.         return $constructorImpl . ($toUnset === [] ? '' : '        unset(' . implode(', ', $toUnset) . ");\n")
  480.             . <<<'EOT'
  482.         $this->__initializer__ = $initializer;
  483.         $this->__cloner__      = $cloner;
  484.     }
  485. EOT;
  486.     }
  488.     /**
  489.      * Generates the magic getter invoked when lazy loaded public properties are requested.
  490.      *
  491.      * @return string
  492.      */
  493.     private function generateMagicGet(ClassMetadata $class)
  494.     {
  495.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  496.         $reflectionClass      = $class->getReflectionClass();
  497.         $hasParentGet         = false;
  498.         $returnReference      = '';
  499.         $inheritDoc           = '';
  500.         $name                 = '$name';
  501.         $parametersString     = '$name';
  502.         $returnTypeHint       = null;
  504.         if ($reflectionClass->hasMethod('__get')) {
  505.             $hasParentGet     = true;
  506.             $inheritDoc       = '{@inheritDoc}';
  507.             $methodReflection = $reflectionClass->getMethod('__get');
  509.             if ($methodReflection->returnsReference()) {
  510.                 $returnReference = '& ';
  511.             }
  513.             $methodParameters = $methodReflection->getParameters();
  514.             $name             = '$' . $methodParameters[0]->getName();
  516.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name']);
  517.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  518.         }
  520.         if (empty($lazyPublicProperties) && ! $hasParentGet) {
  521.             return '';
  522.         }
  524.         $magicGet = <<<EOT
  525.     /**
  526.      * $inheritDoc
  527.      * @param string \$name
  528.      */
  529.     public function {$returnReference}__get($parametersString)$returnTypeHint
  530.     {
  532. EOT;
  534.         if (! empty($lazyPublicProperties)) {
  535.             $magicGet .= <<<'EOT'
  536.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  537.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  538. EOT;
  540.             if ($returnTypeHint === ': void') {
  541.                 $magicGet .= "\n            return;";
  542.             } else {
  543.                 $magicGet .= "\n            return \$this->\$name;";
  544.             }
  546.             $magicGet .= <<<'EOT'
  548.         }
  551. EOT;
  552.         }
  554.         if ($hasParentGet) {
  555.             $magicGet .= <<<'EOT'
  556.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  557. EOT;
  559.             if ($returnTypeHint === ': void') {
  560.                 $magicGet .= <<<'EOT'
  562.         parent::__get($name);
  563.         return;
  564. EOT;
  565.             } elseif ($returnTypeHint === ': never') {
  566.                 $magicGet .= <<<'EOT'
  568.         parent::__get($name);
  569. EOT;
  570.             } else {
  571.                 $magicGet .= <<<'EOT'
  573.         return parent::__get($name);
  574. EOT;
  575.             }
  576.         } else {
  577.             $magicGet .= sprintf(<<<EOT
  578.         trigger_error(sprintf('Undefined property: %%s::$%%s', __CLASS__, %s), E_USER_NOTICE);
  580. EOT
  581.                 , $name);
  582.         }
  584.         return $magicGet . "\n    }";
  585.     }
  587.     /**
  588.      * Generates the magic setter (currently unused).
  589.      *
  590.      * @return string
  591.      */
  592.     private function generateMagicSet(ClassMetadata $class)
  593.     {
  594.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  595.         $reflectionClass      = $class->getReflectionClass();
  596.         $hasParentSet         = false;
  597.         $inheritDoc           = '';
  598.         $parametersString     = '$name, $value';
  599.         $returnTypeHint       = null;
  601.         if ($reflectionClass->hasMethod('__set')) {
  602.             $hasParentSet     = true;
  603.             $inheritDoc       = '{@inheritDoc}';
  604.             $methodReflection = $reflectionClass->getMethod('__set');
  606.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name', 'value']);
  607.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  608.         }
  610.         if (empty($lazyPublicProperties) && ! $hasParentSet) {
  611.             return '';
  612.         }
  614.         $magicSet = <<<EOT
  615.     /**
  616.      * $inheritDoc
  617.      * @param string \$name
  618.      * @param mixed  \$value
  619.      */
  620.     public function __set($parametersString)$returnTypeHint
  621.     {
  623. EOT;
  625.         if (! empty($lazyPublicProperties)) {
  626.             $magicSet .= <<<'EOT'
  627.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  628.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  630.             $this->$name = $value;
  632.             return;
  633.         }
  636. EOT;
  637.         }
  639.         if ($hasParentSet) {
  640.             $magicSet .= <<<'EOT'
  641.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  642. EOT;
  644.             if ($returnTypeHint === ': void') {
  645.                 $magicSet .= <<<'EOT'
  647.         parent::__set($name, $value);
  648.         return;
  649. EOT;
  650.             } elseif ($returnTypeHint === ': never') {
  651.                 $magicSet .= <<<'EOT'
  653.         parent::__set($name, $value);
  654. EOT;
  655.             } else {
  656.                 $magicSet .= <<<'EOT'
  658.         return parent::__set($name, $value);
  659. EOT;
  660.             }
  661.         } else {
  662.             $magicSet .= '        $this->$name = $value;';
  663.         }
  665.         return $magicSet . "\n    }";
  666.     }
  668.     /**
  669.      * Generates the magic issetter invoked when lazy loaded public properties are checked against isset().
  670.      *
  671.      * @return string
  672.      */
  673.     private function generateMagicIsset(ClassMetadata $class)
  674.     {
  675.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  676.         $hasParentIsset       = $class->getReflectionClass()->hasMethod('__isset');
  677.         $parametersString     = '$name';
  678.         $returnTypeHint       = null;
  680.         if ($hasParentIsset) {
  681.             $methodReflection = $class->getReflectionClass()->getMethod('__isset');
  682.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name']);
  683.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  684.         }
  686.         if (empty($lazyPublicProperties) && ! $hasParentIsset) {
  687.             return '';
  688.         }
  690.         $inheritDoc = $hasParentIsset ? '{@inheritDoc}' : '';
  691.         $magicIsset = <<<EOT
  692.     /**
  693.      * $inheritDoc
  694.      * @param  string \$name
  695.      * @return boolean
  696.      */
  697.     public function __isset($parametersString)$returnTypeHint
  698.     {
  700. EOT;
  702.         if (! empty($lazyPublicProperties)) {
  703.             $magicIsset .= <<<'EOT'
  704.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  705.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  707.             return isset($this->$name);
  708.         }
  711. EOT;
  712.         }
  714.         if ($hasParentIsset) {
  715.             $magicIsset .= <<<'EOT'
  716.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  718.         return parent::__isset($name);
  719. EOT;
  720.         } else {
  721.             $magicIsset .= '        return false;';
  722.         }
  724.         return $magicIsset . "\n    }";
  725.     }
  727.     /**
  728.      * Generates implementation for the `__sleep` method of proxies.
  729.      *
  730.      * @return string
  731.      */
  732.     private function generateSleepImpl(ClassMetadata $class)
  733.     {
  734.         $reflectionClass = $class->getReflectionClass();
  736.         $hasParentSleep = $reflectionClass->hasMethod('__sleep');
  737.         $inheritDoc     = $hasParentSleep ? '{@inheritDoc}' : '';
  738.         $returnTypeHint = $hasParentSleep ? $this->getMethodReturnType($reflectionClass->getMethod('__sleep')) : '';
  739.         $sleepImpl      = <<<EOT
  740.     /**
  741.      * $inheritDoc
  742.      * @return array
  743.      */
  744.     public function __sleep()$returnTypeHint
  745.     {
  747. EOT;
  749.         if ($hasParentSleep) {
  750.             return $sleepImpl . <<<'EOT'
  751.         $properties = array_merge(['__isInitialized__'], parent::__sleep());
  753.         if ($this->__isInitialized__) {
  754.             $properties = array_diff($properties, array_keys(self::$lazyPropertiesNames));
  755.         }
  757.         return $properties;
  758.     }
  759. EOT;
  760.         }
  762.         $allProperties = ['__isInitialized__'];
  764.         foreach ($class->getReflectionClass()->getProperties() as $prop) {
  765.             assert($prop instanceof ReflectionProperty);
  766.             if ($prop->isStatic()) {
  767.                 continue;
  768.             }
  770.             $allProperties[] = $prop->isPrivate()
  771.                 ? "\0" . $prop->getDeclaringClass()->getName() . "\0" . $prop->getName()
  772.                 : $prop->getName();
  773.         }
  775.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  776.         $protectedProperties  = array_diff($allProperties, $lazyPublicProperties);
  778.         foreach ($allProperties as &$property) {
  779.             $property = var_export($property, true);
  780.         }
  782.         foreach ($protectedProperties as &$property) {
  783.             $property = var_export($property, true);
  784.         }
  786.         $allProperties       = implode(', ', $allProperties);
  787.         $protectedProperties = implode(', ', $protectedProperties);
  789.         return $sleepImpl . <<<EOT
  790.         if (\$this->__isInitialized__) {
  791.             return [$allProperties];
  792.         }
  794.         return [$protectedProperties];
  795.     }
  796. EOT;
  797.     }
  799.     /**
  800.      * Generates implementation for the `__wakeup` method of proxies.
  801.      *
  802.      * @return string
  803.      */
  804.     private function generateWakeupImpl(ClassMetadata $class)
  805.     {
  806.         $reflectionClass = $class->getReflectionClass();
  808.         $hasParentWakeup = $reflectionClass->hasMethod('__wakeup');
  810.         $unsetPublicProperties = [];
  811.         foreach ($this->getLazyLoadedPublicPropertiesNames($class) as $lazyPublicProperty) {
  812.             $unsetPublicProperties[] = '$this->' . $lazyPublicProperty;
  813.         }
  815.         $shortName      = $this->generateProxyShortClassName($class);
  816.         $inheritDoc     = $hasParentWakeup ? '{@inheritDoc}' : '';
  817.         $returnTypeHint = $hasParentWakeup ? $this->getMethodReturnType($reflectionClass->getMethod('__wakeup')) : '';
  818.         $wakeupImpl     = <<<EOT
  819.     /**
  820.      * $inheritDoc
  821.      */
  822.     public function __wakeup()$returnTypeHint
  823.     {
  824.         if ( ! \$this->__isInitialized__) {
  825.             \$this->__initializer__ = function ($shortName \$proxy) {
  826.                 \$proxy->__setInitializer(null);
  827.                 \$proxy->__setCloner(null);
  829.                 \$existingProperties = get_object_vars(\$proxy);
  831.                 foreach (\$proxy::\$lazyPropertiesDefaults as \$property => \$defaultValue) {
  832.                     if ( ! array_key_exists(\$property, \$existingProperties)) {
  833.                         \$proxy->\$property = \$defaultValue;
  834.                     }
  835.                 }
  836.             };
  838. EOT;
  840.         if (! empty($unsetPublicProperties)) {
  841.             $wakeupImpl .= "\n            unset(" . implode(', ', $unsetPublicProperties) . ');';
  842.         }
  844.         $wakeupImpl .= "\n        }";
  846.         if ($hasParentWakeup) {
  847.             $wakeupImpl .= "\n        parent::__wakeup();";
  848.         }
  850.         $wakeupImpl .= "\n    }";
  852.         return $wakeupImpl;
  853.     }
  855.     /**
  856.      * Generates implementation for the `__clone` method of proxies.
  857.      *
  858.      * @return string
  859.      */
  860.     private function generateCloneImpl(ClassMetadata $class)
  861.     {
  862.         $hasParentClone  = $class->getReflectionClass()->hasMethod('__clone');
  863.         $inheritDoc      = $hasParentClone ? '{@inheritDoc}' : '';
  864.         $callParentClone = $hasParentClone ? "\n        parent::__clone();\n" : '';
  866.         return <<<EOT
  867.     /**
  868.      * $inheritDoc
  869.      */
  870.     public function __clone()
  871.     {
  872.         \$this->__cloner__ && \$this->__cloner__->__invoke(\$this, '__clone', []);
  873. $callParentClone    }
  874. EOT;
  875.     }
  877.     /**
  878.      * Generates decorated methods by picking those available in the parent class.
  879.      *
  880.      * @return string
  881.      */
  882.     private function generateMethods(ClassMetadata $class)
  883.     {
  884.         $methods           = '';
  885.         $methodNames       = [];
  886.         $reflectionMethods = $class->getReflectionClass()->getMethods(ReflectionMethod::IS_PUBLIC);
  887.         $skippedMethods    = [
  888.             '__sleep'   => true,
  889.             '__clone'   => true,
  890.             '__wakeup'  => true,
  891.             '__get'     => true,
  892.             '__set'     => true,
  893.             '__isset'   => true,
  894.         ];
  896.         foreach ($reflectionMethods as $method) {
  897.             $name = $method->getName();
  899.             if (
  900.                 $method->isConstructor() ||
  901.                 isset($skippedMethods[strtolower($name)]) ||
  902.                 isset($methodNames[$name]) ||
  903.                 $method->isFinal() ||
  904.                 $method->isStatic() ||
  905.                 ( ! $method->isPublic())
  906.             ) {
  907.                 continue;
  908.             }
  910.             $methodNames[$name] = true;
  911.             $methods           .= "\n    /**\n"
  912.                 . "     * {@inheritDoc}\n"
  913.                 . "     */\n"
  914.                 . '    public function ';
  916.             if ($method->returnsReference()) {
  917.                 $methods .= '&';
  918.             }
  920.             $methods .= $name . '(' . $this->buildParametersString($method->getParameters()) . ')';
  921.             $methods .= $this->getMethodReturnType($method);
  922.             $methods .= "\n" . '    {' . "\n";
  924.             if ($this->isShortIdentifierGetter($method, $class)) {
  925.                 $identifier = lcfirst(substr($name, 3));
  926.                 $fieldType  = $class->getTypeOfField($identifier);
  927.                 $cast       = in_array($fieldType, ['integer', 'smallint']) ? '(int) ' : '';
  929.                 $methods .= '        if ($this->__isInitialized__ === false) {' . "\n";
  930.                 $methods .= '            ';
  931.                 $methods .= $this->shouldProxiedMethodReturn($method) ? 'return ' : '';
  932.                 $methods .= $cast . ' parent::' . $method->getName() . "();\n";
  933.                 $methods .= '        }' . "\n\n";
  934.             }
  936.             $invokeParamsString = implode(', ', $this->getParameterNamesForInvoke($method->getParameters()));
  937.             $callParamsString   = implode(', ', $this->getParameterNamesForParentCall($method->getParameters()));
  939.             $methods .= "\n        \$this->__initializer__ "
  940.                 . '&& $this->__initializer__->__invoke($this, ' . var_export($name, true)
  941.                 . ', [' . $invokeParamsString . ']);'
  942.                 . "\n\n        "
  943.                 . ($this->shouldProxiedMethodReturn($method) ? 'return ' : '')
  944.                 . 'parent::' . $name . '(' . $callParamsString . ');'
  945.                 . "\n" . '    }' . "\n";
  946.         }
  948.         return $methods;
  949.     }
  951.     /**
  952.      * Generates the Proxy file name.
  953.      *
  954.      * @param string $className
  955.      * @param string $baseDirectory Optional base directory for proxy file name generation.
  956.      *                              If not specified, the directory configured on the Configuration of the
  957.      *                              EntityManager will be used by this factory.
  958.      * @psalm-param class-string $className
  959.      *
  960.      * @return string
  961.      */
  962.     public function getProxyFileName($className, $baseDirectory = null)
  963.     {
  964.         $baseDirectory = $baseDirectory ?: $this->proxyDirectory;
  966.         return rtrim($baseDirectory, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . Proxy::MARKER
  967.             . str_replace('\\', '', $className) . '.php';
  968.     }
  970.     /**
  971.      * Checks if the method is a short identifier getter.
  972.      *
  973.      * What does this mean? For proxy objects the identifier is already known,
  974.      * however accessing the getter for this identifier usually triggers the
  975.      * lazy loading, leading to a query that may not be necessary if only the
  976.      * ID is interesting for the userland code (for example in views that
  977.      * generate links to the entity, but do not display anything else).
  978.      *
  979.      * @param ReflectionMethod $method
  980.      *
  981.      * @return bool
  982.      */
  983.     private function isShortIdentifierGetter($method, ClassMetadata $class)
  984.     {
  985.         $identifier = lcfirst(substr($method->getName(), 3));
  986.         $startLine  = $method->getStartLine();
  987.         $endLine    = $method->getEndLine();
  988.         $cheapCheck = $method->getNumberOfParameters() === 0
  989.             && substr($method->getName(), 0, 3) === 'get'
  990.             && in_array($identifier, $class->getIdentifier(), true)
  991.             && $class->hasField($identifier)
  992.             && ($endLine - $startLine <= 4);
  994.         if ($cheapCheck) {
  995.             $code = file($method->getFileName());
  996.             $code = trim(implode(' ', array_slice($code, $startLine - 1, $endLine - $startLine + 1)));
  998.             $pattern = sprintf(self::PATTERN_MATCH_ID_METHOD, $method->getName(), $identifier);
  1000.             if (preg_match($pattern, $code)) {
  1001.                 return true;
  1002.             }
  1003.         }
  1005.         return false;
  1006.     }
  1008.     /**
  1009.      * Generates the list of public properties to be lazy loaded.
  1010.      *
  1011.      * @return array<int, string>
  1012.      */
  1013.     private function getLazyLoadedPublicPropertiesNames(ClassMetadata $class): array
  1014.     {
  1015.         $properties = [];
  1017.         foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  1018.             $name = $property->getName();
  1020.             if ((! $class->hasField($name) && ! $class->hasAssociation($name)) || $class->isIdentifier($name)) {
  1021.                 continue;
  1022.             }
  1024.             $properties[] = $name;
  1025.         }
  1027.         return $properties;
  1028.     }
  1030.     /**
  1031.      * Generates the list of default values of public properties.
  1032.      *
  1033.      * @return mixed[]
  1034.      */
  1035.     private function getLazyLoadedPublicProperties(ClassMetadata $class)
  1036.     {
  1037.         $defaultProperties          = $class->getReflectionClass()->getDefaultProperties();
  1038.         $lazyLoadedPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  1039.         $defaultValues              = [];
  1041.         foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  1042.             $name = $property->getName();
  1044.             if (! in_array($name, $lazyLoadedPublicProperties, true)) {
  1045.                 continue;
  1046.             }
  1048.             if (array_key_exists($name, $defaultProperties)) {
  1049.                 $defaultValues[$name] = $defaultProperties[$name];
  1050.             } elseif (method_exists($property, 'getType')) {
  1051.                 $propertyType = $property->getType();
  1052.                 if ($propertyType !== null && $propertyType->allowsNull()) {
  1053.                     $defaultValues[$name] = null;
  1054.                 }
  1055.             }
  1056.         }
  1058.         return $defaultValues;
  1059.     }
  1061.     /**
  1062.      * @param ReflectionParameter[] $parameters
  1063.      * @param string[]              $renameParameters
  1064.      *
  1065.      * @return string
  1066.      */
  1067.     private function buildParametersString(array $parameters, array $renameParameters = [])
  1068.     {
  1069.         $parameterDefinitions = [];
  1071.         $i = -1;
  1072.         foreach ($parameters as $param) {
  1073.             assert($param instanceof ReflectionParameter);
  1074.             $i++;
  1075.             $parameterDefinition = '';
  1076.             $parameterType       = $this->getParameterType($param);
  1078.             if ($parameterType !== null) {
  1079.                 $parameterDefinition .= $parameterType . ' ';
  1080.             }
  1082.             if ($param->isPassedByReference()) {
  1083.                 $parameterDefinition .= '&';
  1084.             }
  1086.             if ($param->isVariadic()) {
  1087.                 $parameterDefinition .= '...';
  1088.             }
  1090.             $parameterDefinition .= '$' . ($renameParameters ? $renameParameters[$i] : $param->getName());
  1092.             if ($param->isDefaultValueAvailable()) {
  1093.                 $parameterDefinition .= ' = ' . var_export($param->getDefaultValue(), true);
  1094.             }
  1096.             $parameterDefinitions[] = $parameterDefinition;
  1097.         }
  1099.         return implode(', ', $parameterDefinitions);
  1100.     }
  1102.     /**
  1103.      * @return string|null
  1104.      */
  1105.     private function getParameterType(ReflectionParameter $parameter)
  1106.     {
  1107.         if (! $parameter->hasType()) {
  1108.             return null;
  1109.         }
  1111.         $declaringFunction = $parameter->getDeclaringFunction();
  1113.         assert($declaringFunction instanceof ReflectionMethod);
  1115.         return $this->formatType($parameter->getType(), $declaringFunction, $parameter);
  1116.     }
  1118.     /**
  1119.      * @param ReflectionParameter[] $parameters
  1120.      *
  1121.      * @return string[]
  1122.      */
  1123.     private function getParameterNamesForInvoke(array $parameters)
  1124.     {
  1125.         return array_map(
  1126.             static function (ReflectionParameter $parameter) {
  1127.                 return '$' . $parameter->getName();
  1128.             },
  1129.             $parameters
  1130.         );
  1131.     }
  1133.     /**
  1134.      * @param ReflectionParameter[] $parameters
  1135.      *
  1136.      * @return string[]
  1137.      */
  1138.     private function getParameterNamesForParentCall(array $parameters)
  1139.     {
  1140.         return array_map(
  1141.             static function (ReflectionParameter $parameter) {
  1142.                 $name = '';
  1144.                 if ($parameter->isVariadic()) {
  1145.                     $name .= '...';
  1146.                 }
  1148.                 $name .= '$' . $parameter->getName();
  1150.                 return $name;
  1151.             },
  1152.             $parameters
  1153.         );
  1154.     }
  1156.     /**
  1157.      * @return string
  1158.      */
  1159.     private function getMethodReturnType(ReflectionMethod $method)
  1160.     {
  1161.         if (! $method->hasReturnType()) {
  1162.             return '';
  1163.         }
  1165.         return ': ' . $this->formatType($method->getReturnType(), $method);
  1166.     }
  1168.     /**
  1169.      * @return bool
  1170.      */
  1171.     private function shouldProxiedMethodReturn(ReflectionMethod $method)
  1172.     {
  1173.         if (! $method->hasReturnType()) {
  1174.             return true;
  1175.         }
  1177.         return ! in_array(
  1178.             strtolower($this->formatType($method->getReturnType(), $method)),
  1179.             ['void', 'never'],
  1180.             true
  1181.         );
  1182.     }
  1184.     /**
  1185.      * @return string
  1186.      */
  1187.     private function formatType(
  1188.         ReflectionType $type,
  1189.         ReflectionMethod $method,
  1190.         ?ReflectionParameter $parameter = null
  1191.     ) {
  1192.         if ($type instanceof ReflectionUnionType) {
  1193.             return implode('|', array_map(
  1194.                 function (ReflectionType $unionedType) use ($method, $parameter) {
  1195.                     return $this->formatType($unionedType, $method, $parameter);
  1196.                 },
  1197.                 $type->getTypes()
  1198.             ));
  1199.         }
  1201.         if ($type instanceof ReflectionIntersectionType) {
  1202.             return implode('&', array_map(
  1203.                 function (ReflectionType $intersectedType) use ($method, $parameter) {
  1204.                     return $this->formatType($intersectedType, $method, $parameter);
  1205.                 },
  1206.                 $type->getTypes()
  1207.             ));
  1208.         }
  1210.         assert($type instanceof ReflectionNamedType);
  1212.         $name      = $type->getName();
  1213.         $nameLower = strtolower($name);
  1215.         if ($nameLower === 'static') {
  1216.             $name = 'static';
  1217.         }
  1219.         if ($nameLower === 'self') {
  1220.             $name = $method->getDeclaringClass()->getName();
  1221.         }
  1223.         if ($nameLower === 'parent') {
  1224.             $name = $method->getDeclaringClass()->getParentClass()->getName();
  1225.         }
  1227.         if (! $type->isBuiltin() && ! class_exists($name) && ! interface_exists($name) && $name !== 'static') {
  1228.             if ($parameter !== null) {
  1229.                 throw UnexpectedValueException::invalidParameterTypeHint(
  1230.                     $method->getDeclaringClass()->getName(),
  1231.                     $method->getName(),
  1232.                     $parameter->getName()
  1233.                 );
  1234.             }
  1236.             throw UnexpectedValueException::invalidReturnTypeHint(
  1237.                 $method->getDeclaringClass()->getName(),
  1238.                 $method->getName()
  1239.             );
  1240.         }
  1242.         if (! $type->isBuiltin() && $name !== 'static') {
  1243.             $name = '\\' . $name;
  1244.         }
  1246.         if (
  1247.             $type->allowsNull()
  1248.             && ! in_array($name, ['mixed', 'null'], true)
  1249.             && ($parameter === null || ! $parameter->isDefaultValueAvailable() || $parameter->getDefaultValue() !== null)
  1250.         ) {
  1251.             $name = '?' . $name;
  1252.         }
  1254.         return $name;
  1255.     }
  1256. }