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

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. * @deprecated The ProxyGenerator class is deprecated since doctrine/common 3.5.
  72. */
  73. class ProxyGenerator
  74. {
  75. /**
  76. * Used to match very simple id methods that don't need
  77. * to be decorated since the identifier is known.
  78. */
  79. public const PATTERN_MATCH_ID_METHOD = <<<'EOT'
  80. ((?(DEFINE)
  81. (?<type>\\?[a-z_\x7f-\xff][\w\x7f-\xff]*(?:\\[a-z_\x7f-\xff][\w\x7f-\xff]*)*)
  82. (?<intersection_type>(?&type)\s*&\s*(?&type))
  83. (?<union_type>(?:(?:\(\s*(?&intersection_type)\s*\))|(?&type))(?:\s*\|\s*(?:(?:\(\s*(?&intersection_type)\s*\))|(?&type)))+)
  84. )(?:public\s+)?(?:function\s+%s\s*\(\)\s*)\s*(?::\s*(?:(?&union_type)|(?&intersection_type)|(?:\??(?&type)))\s*)?{\s*return\s*\$this->%s;\s*})i
  85. EOT;
  87. /**
  88. * The namespace that contains all proxy classes.
  89. *
  90. * @var string
  91. */
  92. private $proxyNamespace;
  94. /**
  95. * The directory that contains all proxy classes.
  96. *
  97. * @var string
  98. */
  99. private $proxyDirectory;
  101. /**
  102. * Map of callables used to fill in placeholders set in the template.
  103. *
  104. * @var string[]|callable[]
  105. */
  106. protected $placeholders = [
  107. 'baseProxyInterface' => Proxy::class,
  108. 'additionalProperties' => '',
  109. ];
  111. /**
  112. * Template used as a blueprint to generate proxies.
  113. *
  114. * @var string
  115. */
  116. protected $proxyClassTemplate = '<?php
  118. namespace <namespace>;
  119. <enumUseStatements>
  120. /**
  121. * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE\'S PROXY GENERATOR
  122. */
  123. class <proxyShortClassName> extends \<className> implements \<baseProxyInterface>
  124. {
  125. /**
  126. * @var \Closure the callback responsible for loading properties in the proxy object. This callback is called with
  127. * three parameters, being respectively the proxy object to be initialized, the method that triggered the
  128. * initialization process and an array of ordered parameters that were passed to that method.
  129. *
  130. * @see \Doctrine\Common\Proxy\Proxy::__setInitializer
  131. */
  132. public $__initializer__;
  134. /**
  135. * @var \Closure the callback responsible of loading properties that need to be copied in the cloned object
  136. *
  137. * @see \Doctrine\Common\Proxy\Proxy::__setCloner
  138. */
  139. public $__cloner__;
  141. /**
  142. * @var boolean flag indicating if this object was already initialized
  143. *
  144. * @see \Doctrine\Persistence\Proxy::__isInitialized
  145. */
  146. public $__isInitialized__ = false;
  148. /**
  149. * @var array<string, null> properties to be lazy loaded, indexed by property name
  150. */
  151. public static $lazyPropertiesNames = <lazyPropertiesNames>;
  153. /**
  154. * @var array<string, mixed> default values of properties to be lazy loaded, with keys being the property names
  155. *
  156. * @see \Doctrine\Common\Proxy\Proxy::__getLazyProperties
  157. */
  158. public static $lazyPropertiesDefaults = <lazyPropertiesDefaults>;
  160. <additionalProperties>
  162. <constructorImpl>
  164. <magicGet>
  166. <magicSet>
  168. <magicIsset>
  170. <sleepImpl>
  172. <wakeupImpl>
  174. <cloneImpl>
  176. /**
  177. * Forces initialization of the proxy
  178. */
  179. public function __load(): void
  180. {
  181. $this->__initializer__ && $this->__initializer__->__invoke($this, \'__load\', []);
  182. }
  184. /**
  185. * {@inheritDoc}
  186. * @internal generated method: use only when explicitly handling proxy specific loading logic
  187. */
  188. public function __isInitialized(): bool
  189. {
  190. return $this->__isInitialized__;
  191. }
  193. /**
  194. * {@inheritDoc}
  195. * @internal generated method: use only when explicitly handling proxy specific loading logic
  196. */
  197. public function __setInitialized($initialized): void
  198. {
  199. $this->__isInitialized__ = $initialized;
  200. }
  202. /**
  203. * {@inheritDoc}
  204. * @internal generated method: use only when explicitly handling proxy specific loading logic
  205. */
  206. public function __setInitializer(?\Closure $initializer = null): void
  207. {
  208. $this->__initializer__ = $initializer;
  209. }
  211. /**
  212. * {@inheritDoc}
  213. * @internal generated method: use only when explicitly handling proxy specific loading logic
  214. */
  215. public function __getInitializer(): ?\Closure
  216. {
  217. return $this->__initializer__;
  218. }
  220. /**
  221. * {@inheritDoc}
  222. * @internal generated method: use only when explicitly handling proxy specific loading logic
  223. */
  224. public function __setCloner(?\Closure $cloner = null): void
  225. {
  226. $this->__cloner__ = $cloner;
  227. }
  229. /**
  230. * {@inheritDoc}
  231. * @internal generated method: use only when explicitly handling proxy specific cloning logic
  232. */
  233. public function __getCloner(): ?\Closure
  234. {
  235. return $this->__cloner__;
  236. }
  238. /**
  239. * {@inheritDoc}
  240. * @internal generated method: use only when explicitly handling proxy specific loading logic
  241. * @deprecated no longer in use - generated code now relies on internal components rather than generated public API
  242. * @static
  243. */
  244. public function __getLazyProperties(): array
  245. {
  246. return self::$lazyPropertiesDefaults;
  247. }
  249. <methods>
  250. }
  251. ';
  253. /**
  254. * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
  255. * connected to the given <tt>EntityManager</tt>.
  256. *
  257. * @param string $proxyDirectory The directory to use for the proxy classes. It must exist.
  258. * @param string $proxyNamespace The namespace to use for the proxy classes.
  259. *
  260. * @throws InvalidArgumentException
  261. */
  262. public function __construct($proxyDirectory, $proxyNamespace)
  263. {
  264. if (! $proxyDirectory) {
  265. throw InvalidArgumentException::proxyDirectoryRequired();
  266. }
  268. if (! $proxyNamespace) {
  269. throw InvalidArgumentException::proxyNamespaceRequired();
  270. }
  272. $this->proxyDirectory = $proxyDirectory;
  273. $this->proxyNamespace = $proxyNamespace;
  274. }
  276. /**
  277. * Sets a placeholder to be replaced in the template.
  278. *
  279. * @param string $name
  280. * @param string|callable $placeholder
  281. *
  282. * @throws InvalidArgumentException
  283. */
  284. public function setPlaceholder($name, $placeholder)
  285. {
  286. if (! is_string($placeholder) && ! is_callable($placeholder)) {
  287. throw InvalidArgumentException::invalidPlaceholder($name);
  288. }
  290. $this->placeholders[$name] = $placeholder;
  291. }
  293. /**
  294. * Sets the base template used to create proxy classes.
  295. *
  296. * @param string $proxyClassTemplate
  297. */
  298. public function setProxyClassTemplate($proxyClassTemplate)
  299. {
  300. $this->proxyClassTemplate = (string) $proxyClassTemplate;
  301. }
  303. /**
  304. * Generates a proxy class file.
  305. *
  306. * @param ClassMetadata $class Metadata for the original class.
  307. * @param string|bool $fileName Filename (full path) for the generated class. If none is given, eval() is used.
  308. *
  309. * @throws InvalidArgumentException
  310. * @throws UnexpectedValueException
  311. */
  312. public function generateProxyClass(ClassMetadata $class, $fileName = false)
  313. {
  314. $this->verifyClassCanBeProxied($class);
  316. preg_match_all('(<([a-zA-Z]+)>)', $this->proxyClassTemplate, $placeholderMatches);
  318. $placeholderMatches = array_combine($placeholderMatches[0], $placeholderMatches[1]);
  319. $placeholders = [];
  321. foreach ($placeholderMatches as $placeholder => $name) {
  322. $placeholders[$placeholder] = $this->placeholders[$name] ?? [$this, 'generate' . $name];
  323. }
  325. foreach ($placeholders as & $placeholder) {
  326. if (! is_callable($placeholder)) {
  327. continue;
  328. }
  330. $placeholder = call_user_func($placeholder, $class);
  331. }
  333. $proxyCode = strtr($this->proxyClassTemplate, $placeholders);
  335. if (! $fileName) {
  336. $proxyClassName = $this->generateNamespace($class) . '\\' . $this->generateProxyShortClassName($class);
  338. if (! class_exists($proxyClassName)) {
  339. eval(substr($proxyCode, 5));
  340. }
  342. return;
  343. }
  345. $parentDirectory = dirname($fileName);
  347. if (! is_dir($parentDirectory) && (@mkdir($parentDirectory, 0775, true) === false)) {
  348. throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  349. }
  351. if (! is_writable($parentDirectory)) {
  352. throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  353. }
  355. $tmpFileName = $fileName . '.' . bin2hex(random_bytes(12));
  357. file_put_contents($tmpFileName, $proxyCode);
  358. @chmod($tmpFileName, 0664);
  359. rename($tmpFileName, $fileName);
  360. }
  362. /** @throws InvalidArgumentException */
  363. private function verifyClassCanBeProxied(ClassMetadata $class)
  364. {
  365. if ($class->getReflectionClass()->isFinal()) {
  366. throw InvalidArgumentException::classMustNotBeFinal($class->getName());
  367. }
  369. if ($class->getReflectionClass()->isAbstract()) {
  370. throw InvalidArgumentException::classMustNotBeAbstract($class->getName());
  371. }
  373. if (PHP_VERSION_ID >= 80200 && $class->getReflectionClass()->isReadOnly()) {
  374. throw InvalidArgumentException::classMustNotBeReadOnly($class->getName());
  375. }
  376. }
  378. /**
  379. * Generates the proxy short class name to be used in the template.
  380. *
  381. * @return string
  382. */
  383. private function generateProxyShortClassName(ClassMetadata $class)
  384. {
  385. $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  386. $parts = explode('\\', strrev($proxyClassName), 2);
  388. return strrev($parts[0]);
  389. }
  391. /**
  392. * Generates the proxy namespace.
  393. *
  394. * @return string
  395. */
  396. private function generateNamespace(ClassMetadata $class)
  397. {
  398. $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  399. $parts = explode('\\', strrev($proxyClassName), 2);
  401. return strrev($parts[1]);
  402. }
  404. /**
  405. * Enums must have a use statement when used as public property defaults.
  406. */
  407. public function generateEnumUseStatements(ClassMetadata $class): string
  408. {
  409. if (PHP_VERSION_ID < 80100) {
  410. return "\n";
  411. }
  413. $defaultProperties = $class->getReflectionClass()->getDefaultProperties();
  414. $lazyLoadedPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  415. $enumClasses = [];
  417. foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  418. $name = $property->getName();
  420. if (! in_array($name, $lazyLoadedPublicProperties, true)) {
  421. continue;
  422. }
  424. if (array_key_exists($name, $defaultProperties) && $defaultProperties[$name] instanceof BackedEnum) {
  425. $enumClassNameParts = explode('\\', get_class($defaultProperties[$name]));
  426. $enumClasses[] = $enumClassNameParts[0];
  427. }
  428. }
  430. return implode(
  431. "\n",
  432. array_map(
  433. static function ($className) {
  434. return 'use ' . $className . ';';
  435. },
  436. array_unique($enumClasses)
  437. )
  438. ) . "\n";
  439. }
  441. /**
  442. * Generates the original class name.
  443. *
  444. * @return string
  445. */
  446. private function generateClassName(ClassMetadata $class)
  447. {
  448. return ltrim($class->getName(), '\\');
  449. }
  451. /**
  452. * Generates the array representation of lazy loaded public properties and their default values.
  453. *
  454. * @return string
  455. */
  456. private function generateLazyPropertiesNames(ClassMetadata $class)
  457. {
  458. $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  459. $values = [];
  461. foreach ($lazyPublicProperties as $name) {
  462. $values[$name] = null;
  463. }
  465. return var_export($values, true);
  466. }
  468. /**
  469. * Generates the array representation of lazy loaded public properties names.
  470. *
  471. * @return string
  472. */
  473. private function generateLazyPropertiesDefaults(ClassMetadata $class)
  474. {
  475. return var_export($this->getLazyLoadedPublicProperties($class), true);
  476. }
  478. /**
  479. * Generates the constructor code (un-setting public lazy loaded properties, setting identifier field values).
  480. *
  481. * @return string
  482. */
  483. private function generateConstructorImpl(ClassMetadata $class)
  484. {
  485. $constructorImpl = <<<'EOT'
  486. public function __construct(?\Closure $initializer = null, ?\Closure $cloner = null)
  487. {
  489. EOT;
  491. $toUnset = array_map(static function (string $name): string {
  492. return '$this->' . $name;
  493. }, $this->getLazyLoadedPublicPropertiesNames($class));
  495. return $constructorImpl . ($toUnset === [] ? '' : ' unset(' . implode(', ', $toUnset) . ");\n")
  496. . <<<'EOT'
  498. $this->__initializer__ = $initializer;
  499. $this->__cloner__ = $cloner;
  500. }
  501. EOT;
  502. }
  504. /**
  505. * Generates the magic getter invoked when lazy loaded public properties are requested.
  506. *
  507. * @return string
  508. */
  509. private function generateMagicGet(ClassMetadata $class)
  510. {
  511. $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  512. $reflectionClass = $class->getReflectionClass();
  513. $hasParentGet = false;
  514. $returnReference = '';
  515. $inheritDoc = '';
  516. $name = '$name';
  517. $parametersString = '$name';
  518. $returnTypeHint = null;
  520. if ($reflectionClass->hasMethod('__get')) {
  521. $hasParentGet = true;
  522. $inheritDoc = '{@inheritDoc}';
  523. $methodReflection = $reflectionClass->getMethod('__get');
  525. if ($methodReflection->returnsReference()) {
  526. $returnReference = '& ';
  527. }
  529. $methodParameters = $methodReflection->getParameters();
  530. $name = '$' . $methodParameters[0]->getName();
  532. $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name']);
  533. $returnTypeHint = $this->getMethodReturnType($methodReflection);
  534. }
  536. if (empty($lazyPublicProperties) && ! $hasParentGet) {
  537. return '';
  538. }
  540. $magicGet = <<<EOT
  541. /**
  542. * $inheritDoc
  543. * @param string \$name
  544. */
  545. public function {$returnReference}__get($parametersString)$returnTypeHint
  546. {
  548. EOT;
  550. if (! empty($lazyPublicProperties)) {
  551. $magicGet .= <<<'EOT'
  552. if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  553. $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  554. EOT;
  556. if ($returnTypeHint === ': void') {
  557. $magicGet .= "\n return;";
  558. } else {
  559. $magicGet .= "\n return \$this->\$name;";
  560. }
  562. $magicGet .= <<<'EOT'
  564. }
  567. EOT;
  568. }
  570. if ($hasParentGet) {
  571. $magicGet .= <<<'EOT'
  572. $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  573. EOT;
  575. if ($returnTypeHint === ': void') {
  576. $magicGet .= <<<'EOT'
  578. parent::__get($name);
  579. return;
  580. EOT;
  581. } elseif ($returnTypeHint === ': never') {
  582. $magicGet .= <<<'EOT'
  584. parent::__get($name);
  585. EOT;
  586. } else {
  587. $magicGet .= <<<'EOT'
  589. return parent::__get($name);
  590. EOT;
  591. }
  592. } else {
  593. $magicGet .= sprintf(<<<EOT
  594. trigger_error(sprintf('Undefined property: %%s::$%%s', __CLASS__, %s), E_USER_NOTICE);
  596. EOT
  597. , $name);
  598. }
  600. return $magicGet . "\n }";
  601. }
  603. /**
  604. * Generates the magic setter (currently unused).
  605. *
  606. * @return string
  607. */
  608. private function generateMagicSet(ClassMetadata $class)
  609. {
  610. $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  611. $reflectionClass = $class->getReflectionClass();
  612. $hasParentSet = false;
  613. $inheritDoc = '';
  614. $parametersString = '$name, $value';
  615. $returnTypeHint = null;
  617. if ($reflectionClass->hasMethod('__set')) {
  618. $hasParentSet = true;
  619. $inheritDoc = '{@inheritDoc}';
  620. $methodReflection = $reflectionClass->getMethod('__set');
  622. $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name', 'value']);
  623. $returnTypeHint = $this->getMethodReturnType($methodReflection);
  624. }
  626. if (empty($lazyPublicProperties) && ! $hasParentSet) {
  627. return '';
  628. }
  630. $magicSet = <<<EOT
  631. /**
  632. * $inheritDoc
  633. * @param string \$name
  634. * @param mixed \$value
  635. */
  636. public function __set($parametersString)$returnTypeHint
  637. {
  639. EOT;
  641. if (! empty($lazyPublicProperties)) {
  642. $magicSet .= <<<'EOT'
  643. if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  644. $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  646. $this->$name = $value;
  648. return;
  649. }
  652. EOT;
  653. }
  655. if ($hasParentSet) {
  656. $magicSet .= <<<'EOT'
  657. $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  658. EOT;
  660. if ($returnTypeHint === ': void') {
  661. $magicSet .= <<<'EOT'
  663. parent::__set($name, $value);
  664. return;
  665. EOT;
  666. } elseif ($returnTypeHint === ': never') {
  667. $magicSet .= <<<'EOT'
  669. parent::__set($name, $value);
  670. EOT;
  671. } else {
  672. $magicSet .= <<<'EOT'
  674. return parent::__set($name, $value);
  675. EOT;
  676. }
  677. } else {
  678. $magicSet .= ' $this->$name = $value;';
  679. }
  681. return $magicSet . "\n }";
  682. }
  684. /**
  685. * Generates the magic issetter invoked when lazy loaded public properties are checked against isset().
  686. *
  687. * @return string
  688. */
  689. private function generateMagicIsset(ClassMetadata $class)
  690. {
  691. $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  692. $hasParentIsset = $class->getReflectionClass()->hasMethod('__isset');
  693. $parametersString = '$name';
  694. $returnTypeHint = null;
  696. if ($hasParentIsset) {
  697. $methodReflection = $class->getReflectionClass()->getMethod('__isset');
  698. $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name']);
  699. $returnTypeHint = $this->getMethodReturnType($methodReflection);
  700. }
  702. if (empty($lazyPublicProperties) && ! $hasParentIsset) {
  703. return '';
  704. }
  706. $inheritDoc = $hasParentIsset ? '{@inheritDoc}' : '';
  707. $magicIsset = <<<EOT
  708. /**
  709. * $inheritDoc
  710. * @param string \$name
  711. * @return boolean
  712. */
  713. public function __isset($parametersString)$returnTypeHint
  714. {
  716. EOT;
  718. if (! empty($lazyPublicProperties)) {
  719. $magicIsset .= <<<'EOT'
  720. if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  721. $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  723. return isset($this->$name);
  724. }
  727. EOT;
  728. }
  730. if ($hasParentIsset) {
  731. $magicIsset .= <<<'EOT'
  732. $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  734. return parent::__isset($name);
  735. EOT;
  736. } else {
  737. $magicIsset .= ' return false;';
  738. }
  740. return $magicIsset . "\n }";
  741. }
  743. /**
  744. * Generates implementation for the `__sleep` method of proxies.
  745. *
  746. * @return string
  747. */
  748. private function generateSleepImpl(ClassMetadata $class)
  749. {
  750. $reflectionClass = $class->getReflectionClass();
  752. $hasParentSleep = $reflectionClass->hasMethod('__sleep');
  753. $inheritDoc = $hasParentSleep ? '{@inheritDoc}' : '';
  754. $returnTypeHint = $hasParentSleep ? $this->getMethodReturnType($reflectionClass->getMethod('__sleep')) : '';
  755. $sleepImpl = <<<EOT
  756. /**
  757. * $inheritDoc
  758. * @return array
  759. */
  760. public function __sleep()$returnTypeHint
  761. {
  763. EOT;
  765. if ($hasParentSleep) {
  766. return $sleepImpl . <<<'EOT'
  767. $properties = array_merge(['__isInitialized__'], parent::__sleep());
  769. if ($this->__isInitialized__) {
  770. $properties = array_diff($properties, array_keys(self::$lazyPropertiesNames));
  771. }
  773. return $properties;
  774. }
  775. EOT;
  776. }
  778. $allProperties = ['__isInitialized__'];
  780. foreach ($class->getReflectionClass()->getProperties() as $prop) {
  781. assert($prop instanceof ReflectionProperty);
  782. if ($prop->isStatic()) {
  783. continue;
  784. }
  786. $allProperties[] = $prop->isPrivate()
  787. ? "\0" . $prop->getDeclaringClass()->getName() . "\0" . $prop->getName()
  788. : $prop->getName();
  789. }
  791. $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  792. $protectedProperties = array_diff($allProperties, $lazyPublicProperties);
  794. foreach ($allProperties as &$property) {
  795. $property = var_export($property, true);
  796. }
  798. foreach ($protectedProperties as &$property) {
  799. $property = var_export($property, true);
  800. }
  802. $allProperties = implode(', ', $allProperties);
  803. $protectedProperties = implode(', ', $protectedProperties);
  805. return $sleepImpl . <<<EOT
  806. if (\$this->__isInitialized__) {
  807. return [$allProperties];
  808. }
  810. return [$protectedProperties];
  811. }
  812. EOT;
  813. }
  815. /**
  816. * Generates implementation for the `__wakeup` method of proxies.
  817. *
  818. * @return string
  819. */
  820. private function generateWakeupImpl(ClassMetadata $class)
  821. {
  822. $reflectionClass = $class->getReflectionClass();
  824. $hasParentWakeup = $reflectionClass->hasMethod('__wakeup');
  826. $unsetPublicProperties = [];
  827. foreach ($this->getLazyLoadedPublicPropertiesNames($class) as $lazyPublicProperty) {
  828. $unsetPublicProperties[] = '$this->' . $lazyPublicProperty;
  829. }
  831. $shortName = $this->generateProxyShortClassName($class);
  832. $inheritDoc = $hasParentWakeup ? '{@inheritDoc}' : '';
  833. $returnTypeHint = $hasParentWakeup ? $this->getMethodReturnType($reflectionClass->getMethod('__wakeup')) : '';
  834. $wakeupImpl = <<<EOT
  835. /**
  836. * $inheritDoc
  837. */
  838. public function __wakeup()$returnTypeHint
  839. {
  840. if ( ! \$this->__isInitialized__) {
  841. \$this->__initializer__ = function ($shortName \$proxy) {
  842. \$proxy->__setInitializer(null);
  843. \$proxy->__setCloner(null);
  845. \$existingProperties = get_object_vars(\$proxy);
  847. foreach (\$proxy::\$lazyPropertiesDefaults as \$property => \$defaultValue) {
  848. if ( ! array_key_exists(\$property, \$existingProperties)) {
  849. \$proxy->\$property = \$defaultValue;
  850. }
  851. }
  852. };
  854. EOT;
  856. if (! empty($unsetPublicProperties)) {
  857. $wakeupImpl .= "\n unset(" . implode(', ', $unsetPublicProperties) . ');';
  858. }
  860. $wakeupImpl .= "\n }";
  862. if ($hasParentWakeup) {
  863. $wakeupImpl .= "\n parent::__wakeup();";
  864. }
  866. $wakeupImpl .= "\n }";
  868. return $wakeupImpl;
  869. }
  871. /**
  872. * Generates implementation for the `__clone` method of proxies.
  873. *
  874. * @return string
  875. */
  876. private function generateCloneImpl(ClassMetadata $class)
  877. {
  878. $reflectionClass = $class->getReflectionClass();
  879. $hasParentClone = $reflectionClass->hasMethod('__clone');
  880. $returnTypeHint = $hasParentClone ? $this->getMethodReturnType($reflectionClass->getMethod('__clone')) : '';
  881. $inheritDoc = $hasParentClone ? '{@inheritDoc}' : '';
  882. $callParentClone = $hasParentClone ? "\n parent::__clone();\n" : '';
  884. return <<<EOT
  885. /**
  886. * $inheritDoc
  887. */
  888. public function __clone()$returnTypeHint
  889. {
  890. \$this->__cloner__ && \$this->__cloner__->__invoke(\$this, '__clone', []);
  891. $callParentClone }
  892. EOT;
  893. }
  895. /**
  896. * Generates decorated methods by picking those available in the parent class.
  897. *
  898. * @return string
  899. */
  900. private function generateMethods(ClassMetadata $class)
  901. {
  902. $methods = '';
  903. $methodNames = [];
  904. $reflectionMethods = $class->getReflectionClass()->getMethods(ReflectionMethod::IS_PUBLIC);
  905. $skippedMethods = [
  906. '__sleep' => true,
  907. '__clone' => true,
  908. '__wakeup' => true,
  909. '__get' => true,
  910. '__set' => true,
  911. '__isset' => true,
  912. ];
  914. foreach ($reflectionMethods as $method) {
  915. $name = $method->getName();
  917. if (
  918. $method->isConstructor() ||
  919. isset($skippedMethods[strtolower($name)]) ||
  920. isset($methodNames[$name]) ||
  921. $method->isFinal() ||
  922. $method->isStatic() ||
  923. ( ! $method->isPublic())
  924. ) {
  925. continue;
  926. }
  928. $methodNames[$name] = true;
  929. $methods .= "\n /**\n"
  930. . " * {@inheritDoc}\n"
  931. . " */\n"
  932. . ' public function ';
  934. if ($method->returnsReference()) {
  935. $methods .= '&';
  936. }
  938. $methods .= $name . '(' . $this->buildParametersString($method->getParameters()) . ')';
  939. $methods .= $this->getMethodReturnType($method);
  940. $methods .= "\n" . ' {' . "\n";
  942. if ($this->isShortIdentifierGetter($method, $class)) {
  943. $identifier = lcfirst(substr($name, 3));
  944. $fieldType = $class->getTypeOfField($identifier);
  945. $cast = in_array($fieldType, ['integer', 'smallint'], true) ? '(int) ' : '';
  947. $methods .= ' if ($this->__isInitialized__ === false) {' . "\n";
  948. $methods .= ' ';
  949. $methods .= $this->shouldProxiedMethodReturn($method) ? 'return ' : '';
  950. $methods .= $cast . ' parent::' . $method->getName() . "();\n";
  951. $methods .= ' }' . "\n\n";
  952. }
  954. $invokeParamsString = implode(', ', $this->getParameterNamesForInvoke($method->getParameters()));
  955. $callParamsString = implode(', ', $this->getParameterNamesForParentCall($method->getParameters()));
  957. $methods .= "\n \$this->__initializer__ "
  958. . '&& $this->__initializer__->__invoke($this, ' . var_export($name, true)
  959. . ', [' . $invokeParamsString . ']);'
  960. . "\n\n "
  961. . ($this->shouldProxiedMethodReturn($method) ? 'return ' : '')
  962. . 'parent::' . $name . '(' . $callParamsString . ');'
  963. . "\n" . ' }' . "\n";
  964. }
  966. return $methods;
  967. }
  969. /**
  970. * Generates the Proxy file name.
  971. *
  972. * @param string $className
  973. * @param string $baseDirectory Optional base directory for proxy file name generation.
  974. * If not specified, the directory configured on the Configuration of the
  975. * EntityManager will be used by this factory.
  976. * @psalm-param class-string $className
  977. *
  978. * @return string
  979. */
  980. public function getProxyFileName($className, $baseDirectory = null)
  981. {
  982. $baseDirectory = $baseDirectory ?: $this->proxyDirectory;
  984. return rtrim($baseDirectory, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . Proxy::MARKER
  985. . str_replace('\\', '', $className) . '.php';
  986. }
  988. /**
  989. * Checks if the method is a short identifier getter.
  990. *
  991. * What does this mean? For proxy objects the identifier is already known,
  992. * however accessing the getter for this identifier usually triggers the
  993. * lazy loading, leading to a query that may not be necessary if only the
  994. * ID is interesting for the userland code (for example in views that
  995. * generate links to the entity, but do not display anything else).
  996. *
  997. * @param ReflectionMethod $method
  998. *
  999. * @return bool
  1000. */
  1001. private function isShortIdentifierGetter($method, ClassMetadata $class)
  1002. {
  1003. $identifier = lcfirst(substr($method->getName(), 3));
  1004. $startLine = $method->getStartLine();
  1005. $endLine = $method->getEndLine();
  1006. $cheapCheck = $method->getNumberOfParameters() === 0
  1007. && substr($method->getName(), 0, 3) === 'get'
  1008. && in_array($identifier, $class->getIdentifier(), true)
  1009. && $class->hasField($identifier)
  1010. && ($endLine - $startLine <= 4);
  1012. if ($cheapCheck) {
  1013. $code = file($method->getFileName());
  1014. $code = trim(implode(' ', array_slice($code, $startLine - 1, $endLine - $startLine + 1)));
  1016. $pattern = sprintf(self::PATTERN_MATCH_ID_METHOD, $method->getName(), $identifier);
  1018. if (preg_match($pattern, $code)) {
  1019. return true;
  1020. }
  1021. }
  1023. return false;
  1024. }
  1026. /**
  1027. * Generates the list of public properties to be lazy loaded.
  1028. *
  1029. * @return array<int, string>
  1030. */
  1031. private function getLazyLoadedPublicPropertiesNames(ClassMetadata $class): array
  1032. {
  1033. $properties = [];
  1035. foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  1036. $name = $property->getName();
  1038. if ((! $class->hasField($name) && ! $class->hasAssociation($name)) || $class->isIdentifier($name)) {
  1039. continue;
  1040. }
  1042. $properties[] = $name;
  1043. }
  1045. return $properties;
  1046. }
  1048. /**
  1049. * Generates the list of default values of public properties.
  1050. *
  1051. * @return mixed[]
  1052. */
  1053. private function getLazyLoadedPublicProperties(ClassMetadata $class)
  1054. {
  1055. $defaultProperties = $class->getReflectionClass()->getDefaultProperties();
  1056. $lazyLoadedPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  1057. $defaultValues = [];
  1059. foreach ($class->getReflectionClass()->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
  1060. $name = $property->getName();
  1062. if (! in_array($name, $lazyLoadedPublicProperties, true)) {
  1063. continue;
  1064. }
  1066. if (array_key_exists($name, $defaultProperties)) {
  1067. $defaultValues[$name] = $defaultProperties[$name];
  1068. } elseif (method_exists($property, 'getType')) {
  1069. $propertyType = $property->getType();
  1070. if ($propertyType !== null && $propertyType->allowsNull()) {
  1071. $defaultValues[$name] = null;
  1072. }
  1073. }
  1074. }
  1076. return $defaultValues;
  1077. }
  1079. /**
  1080. * @param ReflectionParameter[] $parameters
  1081. * @param string[] $renameParameters
  1082. *
  1083. * @return string
  1084. */
  1085. private function buildParametersString(array $parameters, array $renameParameters = [])
  1086. {
  1087. $parameterDefinitions = [];
  1089. $i = -1;
  1090. foreach ($parameters as $param) {
  1091. assert($param instanceof ReflectionParameter);
  1092. $i++;
  1093. $parameterDefinition = '';
  1094. $parameterType = $this->getParameterType($param);
  1096. if ($parameterType !== null) {
  1097. $parameterDefinition .= $parameterType . ' ';
  1098. }
  1100. if ($param->isPassedByReference()) {
  1101. $parameterDefinition .= '&';
  1102. }
  1104. if ($param->isVariadic()) {
  1105. $parameterDefinition .= '...';
  1106. }
  1108. $parameterDefinition .= '$' . ($renameParameters ? $renameParameters[$i] : $param->getName());
  1109. $parameterDefinition .= $this->getParameterDefaultValue($param);
  1111. $parameterDefinitions[] = $parameterDefinition;
  1112. }
  1114. return implode(', ', $parameterDefinitions);
  1115. }
  1117. /** @return string|null */
  1118. private function getParameterType(ReflectionParameter $parameter)
  1119. {
  1120. if (! $parameter->hasType()) {
  1121. return null;
  1122. }
  1124. $declaringFunction = $parameter->getDeclaringFunction();
  1126. assert($declaringFunction instanceof ReflectionMethod);
  1128. return $this->formatType($parameter->getType(), $declaringFunction, $parameter);
  1129. }
  1131. /** @return string */
  1132. private function getParameterDefaultValue(ReflectionParameter $parameter)
  1133. {
  1134. if (! $parameter->isDefaultValueAvailable()) {
  1135. return '';
  1136. }
  1138. if (PHP_VERSION_ID < 80100 || is_scalar($parameter->getDefaultValue())) {
  1139. return ' = ' . var_export($parameter->getDefaultValue(), true);
  1140. }
  1142. $value = rtrim(substr(explode('$' . $parameter->getName() . ' = ', (string) $parameter, 2)[1], 0, -2));
  1144. if (strpos($value, '\\') !== false || strpos($value, '::') !== false) {
  1145. $value = preg_split("/('(?:[^'\\\\]*+(?:\\\\.)*+)*+')/", $value, -1, PREG_SPLIT_DELIM_CAPTURE);
  1146. foreach ($value as $i => $part) {
  1147. if ($i % 2 === 0) {
  1148. $value[$i] = preg_replace('/(?<![a-zA-Z0-9_\x7f-\xff\\\\])[a-zA-Z0-9_\x7f-\xff]++(?:\\\\[a-zA-Z0-9_\x7f-\xff]++|::)++/', '\\\\\0', $part);
  1149. }
  1150. }
  1152. $value = implode('', $value);
  1153. }
  1155. return ' = ' . $value;
  1156. }
  1158. /**
  1159. * @param ReflectionParameter[] $parameters
  1160. *
  1161. * @return string[]
  1162. */
  1163. private function getParameterNamesForInvoke(array $parameters)
  1164. {
  1165. return array_map(
  1166. static function (ReflectionParameter $parameter) {
  1167. return '$' . $parameter->getName();
  1168. },
  1169. $parameters
  1170. );
  1171. }
  1173. /**
  1174. * @param ReflectionParameter[] $parameters
  1175. *
  1176. * @return string[]
  1177. */
  1178. private function getParameterNamesForParentCall(array $parameters)
  1179. {
  1180. return array_map(
  1181. static function (ReflectionParameter $parameter) {
  1182. $name = '';
  1184. if ($parameter->isVariadic()) {
  1185. $name .= '...';
  1186. }
  1188. $name .= '$' . $parameter->getName();
  1190. return $name;
  1191. },
  1192. $parameters
  1193. );
  1194. }
  1196. /** @return string */
  1197. private function getMethodReturnType(ReflectionMethod $method)
  1198. {
  1199. if (! $method->hasReturnType()) {
  1200. return '';
  1201. }
  1203. return ': ' . $this->formatType($method->getReturnType(), $method);
  1204. }
  1206. /** @return bool */
  1207. private function shouldProxiedMethodReturn(ReflectionMethod $method)
  1208. {
  1209. if (! $method->hasReturnType()) {
  1210. return true;
  1211. }
  1213. return ! in_array(
  1214. strtolower($this->formatType($method->getReturnType(), $method)),
  1215. ['void', 'never'],
  1216. true
  1217. );
  1218. }
  1220. /** @return string */
  1221. private function formatType(
  1222. ReflectionType $type,
  1223. ReflectionMethod $method,
  1224. ?ReflectionParameter $parameter = null
  1225. ) {
  1226. if ($type instanceof ReflectionUnionType) {
  1227. return implode('|', array_map(
  1228. function (ReflectionType $unionedType) use ($method, $parameter) {
  1229. if ($unionedType instanceof ReflectionIntersectionType) {
  1230. return '(' . $this->formatType($unionedType, $method, $parameter) . ')';
  1231. }
  1233. return $this->formatType($unionedType, $method, $parameter);
  1234. },
  1235. $type->getTypes()
  1236. ));
  1237. }
  1239. if ($type instanceof ReflectionIntersectionType) {
  1240. return implode('&', array_map(
  1241. function (ReflectionType $intersectedType) use ($method, $parameter) {
  1242. return $this->formatType($intersectedType, $method, $parameter);
  1243. },
  1244. $type->getTypes()
  1245. ));
  1246. }
  1248. assert($type instanceof ReflectionNamedType);
  1250. $name = $type->getName();
  1251. $nameLower = strtolower($name);
  1253. if ($nameLower === 'static') {
  1254. $name = 'static';
  1255. }
  1257. if ($nameLower === 'self') {
  1258. $name = $method->getDeclaringClass()->getName();
  1259. }
  1261. if ($nameLower === 'parent') {
  1262. $name = $method->getDeclaringClass()->getParentClass()->getName();
  1263. }
  1265. if (! $type->isBuiltin() && ! class_exists($name) && ! interface_exists($name) && $name !== 'static') {
  1266. if ($parameter !== null) {
  1267. throw UnexpectedValueException::invalidParameterTypeHint(
  1268. $method->getDeclaringClass()->getName(),
  1269. $method->getName(),
  1270. $parameter->getName()
  1271. );
  1272. }
  1274. throw UnexpectedValueException::invalidReturnTypeHint(
  1275. $method->getDeclaringClass()->getName(),
  1276. $method->getName()
  1277. );
  1278. }
  1280. if (! $type->isBuiltin() && $name !== 'static') {
  1281. $name = '\\' . $name;
  1282. }
  1284. if (
  1285. $type->allowsNull()
  1286. && ! in_array($name, ['mixed', 'null'], true)
  1287. ) {
  1288. $name = '?' . $name;
  1289. }
  1291. return $name;
  1292. }
  1293. }