.doctrine-project.json000064400000000564144760115550011005 0ustar00{ "active": true, "name": "Reflection", "slug": "reflection", "docsSlug": "doctrine-reflection", "versions": [ { "name": "1.0", "branchName": "master", "slug": "latest", "current": true, "aliases": [ "current", "stable" ] } ] } .scrutinizer.yml000064400000001766144760115550007750 0ustar00build: nodes: analysis: environment: php: version: 7.1 cache: disabled: false directories: - ~/.composer/cache project_setup: override: true tests: override: - php-scrutinizer-run - phpcs-run dependencies: override: - composer install -noa tools: external_code_coverage: timeout: 600 build_failure_conditions: - 'elements.rating(<= C).new.exists' # No new classes/methods with a rating of C or worse allowed - 'issues.label("coding-style").new.exists' # No new coding style issues allowed - 'issues.severity(>= MAJOR).new.exists' # New issues of major or higher severity - 'project.metric_change("scrutinizer.test_coverage", < 0)' # Code Coverage decreased from previous inspection LICENSE000064400000002051144760115550005557 0ustar00Copyright (c) 2006-2015 Doctrine Project Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. README.md000064400000001732144760115550006036 0ustar00# Doctrine Reflection [![Build Status](https://travis-ci.org/doctrine/reflection.svg)](https://travis-ci.org/doctrine/reflection) [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/doctrine/reflection/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/doctrine/reflection/?branch=master) [![Code Coverage](https://scrutinizer-ci.com/g/doctrine/reflection/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/doctrine/reflection/?branch=master) The Doctrine Reflection project is a simple library used by the various Doctrine projects which adds some additional functionality on top of the reflection functionality that comes with PHP. It allows you to get the reflection information about classes, methods and properties statically. ## More resources: * [Website](https://www.doctrine-project.org/) * [Documentation](https://www.doctrine-project.org/projects/doctrine-reflection/en/latest/) * [Downloads](https://github.com/doctrine/reflection/releases) composer.json000064400000003347144760115550007305 0ustar00{ "name": "doctrine/reflection", "type": "library", "description": "The Doctrine Reflection project is a simple library used by the various Doctrine projects which adds some additional functionality on top of the reflection functionality that comes with PHP. It allows you to get the reflection information about classes, methods and properties statically.", "keywords": [ "reflection", "static" ], "homepage": "https://www.doctrine-project.org/projects/reflection.html", "license": "MIT", "authors": [ {"name": "Guilherme Blanco", "email": "guilhermeblanco@gmail.com"}, {"name": "Roman Borschel", "email": "roman@code-factory.org"}, {"name": "Benjamin Eberlei", "email": "kontakt@beberlei.de"}, {"name": "Jonathan Wage", "email": "jonwage@gmail.com"}, {"name": "Johannes Schmitt", "email": "schmittjoh@gmail.com"}, {"name": "Marco Pivetta", "email": "ocramius@gmail.com"} ], "require": { "php": "^7.1", "ext-tokenizer": "*", "doctrine/annotations": "^1.0" }, "require-dev": { "phpstan/phpstan": "^0.11.0", "phpstan/phpstan-phpunit": "^0.11.0", "phpunit/phpunit": "^7.0", "doctrine/coding-standard": "^5.0", "doctrine/common": "^2.10" }, "conflict": { "doctrine/common": "<2.9" }, "autoload": { "psr-4": { "Doctrine\\Common\\": "lib/Doctrine/Common" } }, "autoload-dev": { "psr-4": { "Doctrine\\Tests\\": "tests/Doctrine/Tests", "Doctrine\\Tests_PHP74\\": "tests/Doctrine/Tests_PHP74" } }, "extra": { "branch-alias": { "dev-master": "1.0.x-dev" } } } docs/en/index.rst000064400000001541144760115550007750 0ustar00Reflection Documentation ================= The Doctrine Reflection documentation is a reference guide to everything you need to know about the reflection project. Getting Help ------------ If this documentation is not helping to answer questions you have about Doctrine Reflection don't panic. You can get help from different sources: - The `Doctrine Mailing List `_ - Slack chat room `#reflection `_ - Report a bug on `GitHub `_. - On `StackOverflow `_ Getting Started --------------- The best way to get started is with the :doc:`Introduction ` section. Use the sidebar to browse other documentation for the Doctrine PHP Reflection project. docs/en/reference/index.rst000064400000004065144760115550011712 0ustar00Introduction ============ The Doctrine Reflection project is a simple library used by the various Doctrine projects which adds some additional functionality on top of the reflection functionality that comes with PHP. It allows you to get the reflection information about classes, methods and properties statically. Installation ============ The library can easily be installed with composer. .. code-block:: sh $ composer require doctrine/reflection Setup ===== .. code-block:: php use Doctrine\Common\Reflection\Psr0FindFile; use Doctrine\Common\Reflection\StaticReflectionParser; use App\Model\User; $finder = new Psr0FindFile(['App' => [ '/path/to/project/src/App' ]]); $staticReflectionParser = new StaticReflectionParser(User::class, $finder); Usage ===== .. code-block:: php echo $staticReflectionParser->getClassName(); echo $staticReflectionParser->getNamespaceName(); StaticReflectionClass ===================== .. code-block:: php $staticReflectionClass = $staticReflectionParser->getReflectionClass(); echo $staticReflectionClass->getName(); echo $staticReflectionClass->getDocComment(); echo $staticReflectionClass->getNamespaceName(); print_r($staticReflectionClass->getUseStatements()); StaticReflectionMethod ====================== .. code-block:: php $staticReflectionMethod = $staticReflectionParser->getReflectionMethod('getSomething'); echo $staticReflectionMethod->getName(); echo $staticReflectionMethod->getDeclaringClass(); echo $staticReflectionMethod->getNamespaceName(); echo $staticReflectionMethod->getDocComment(); print_r($staticReflectionMethod->getUseStatements()); StaticReflectionProperty ======================== .. code-block:: php $staticReflectionProperty = $staticReflectionParser->getReflectionProperty('something'); echo $staticReflectionProperty->getName(); echo $staticReflectionProperty->getDeclaringClass(); echo $staticReflectionProperty->getDocComment(); print_r($staticReflectionProperty->getUseStatements()); docs/en/sidebar.rst000064400000000060144760115550010245 0ustar00.. toctree:: :depth: 3 reference/index lib/Doctrine/Common/Reflection/ClassFinderInterface.php000064400000000524144760115550017143 0ustar00prefixes = $prefixes; } /** * {@inheritDoc} */ public function findFile($class) { if ($class[0] === '\\') { $class = substr($class, 1); } $lastNsPos = strrpos($class, '\\'); if ($lastNsPos !== false) { // namespaced class name $classPath = str_replace('\\', DIRECTORY_SEPARATOR, substr($class, 0, $lastNsPos)) . DIRECTORY_SEPARATOR; $className = substr($class, $lastNsPos + 1); } else { // PEAR-like class name $classPath = null; $className = $class; } $classPath .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php'; foreach ($this->prefixes as $prefix => $dirs) { if (strpos($class, $prefix) !== 0) { continue; } foreach ($dirs as $dir) { if (is_file($dir . DIRECTORY_SEPARATOR . $classPath)) { return $dir . DIRECTORY_SEPARATOR . $classPath; } } } return null; } } lib/Doctrine/Common/Reflection/ReflectionProviderInterface.php000064400000001311144760115550020546 0ustar00getName(); if ($object instanceof Proxy && ! $object->__isInitialized()) { $originalInitializer = $object->__getInitializer(); $object->__setInitializer(null); $val = $object->$name ?? null; $object->__setInitializer($originalInitializer); return $val; } return isset($object->$name) ? parent::getValue($object) : null; } /** * {@inheritDoc} * * Avoids triggering lazy loading via `__set` if the provided object * is a {@see \Doctrine\Common\Proxy\Proxy}. * * @link https://bugs.php.net/bug.php?id=63463 */ public function setValue($object, $value = null) { if (! ($object instanceof Proxy && ! $object->__isInitialized())) { parent::setValue($object, $value); return; } $originalInitializer = $object->__getInitializer(); $object->__setInitializer(null); parent::setValue($object, $value); $object->__setInitializer($originalInitializer); } } lib/Doctrine/Common/Reflection/StaticReflectionClass.php000064400000017533144760115550017365 0ustar00staticReflectionParser = $staticReflectionParser; } /** * {@inheritDoc} */ public function getName() { return $this->staticReflectionParser->getClassName(); } /** * {@inheritDoc} */ public function getDocComment() { return $this->staticReflectionParser->getDocComment(); } /** * {@inheritDoc} */ public function getNamespaceName() { return $this->staticReflectionParser->getNamespaceName(); } /** * @return string[] */ public function getUseStatements() { return $this->staticReflectionParser->getUseStatements(); } /** * {@inheritDoc} */ public function getMethod($name) { return $this->staticReflectionParser->getReflectionMethod($name); } /** * {@inheritDoc} */ public function getProperty($name) { return $this->staticReflectionParser->getReflectionProperty($name); } /** * {@inheritDoc} */ public static function export($argument, $return = false) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getConstant($name) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getConstants() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getConstructor() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getDefaultProperties() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getEndLine() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getExtension() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getExtensionName() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getFileName() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getInterfaceNames() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getInterfaces() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getMethods($filter = null) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getModifiers() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getParentClass() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getProperties($filter = null) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getShortName() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getStartLine() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getStaticProperties() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getStaticPropertyValue($name, $default = '') { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getTraitAliases() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getTraitNames() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getTraits() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function hasConstant($name) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function hasMethod($name) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function hasProperty($name) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function implementsInterface($interface) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function inNamespace() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isAbstract() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isCloneable() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isFinal() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isInstance($object) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isInstantiable() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isInterface() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isInternal() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isIterateable() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isSubclassOf($class) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isTrait() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isUserDefined() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function newInstance($args) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function newInstanceArgs(array $args = []) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function newInstanceWithoutConstructor() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function setStaticPropertyValue($name, $value) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function __toString() { throw new ReflectionException('Method not implemented'); } } lib/Doctrine/Common/Reflection/StaticReflectionMethod.php000064400000015113144760115550017530 0ustar00staticReflectionParser = $staticReflectionParser; $this->methodName = $methodName; } /** * {@inheritDoc} */ public function getName() { return $this->methodName; } /** * @return StaticReflectionParser */ protected function getStaticReflectionParser() { return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('method', $this->methodName); } /** * {@inheritDoc} */ public function getDeclaringClass() { return $this->getStaticReflectionParser()->getReflectionClass(); } /** * {@inheritDoc} */ public function getNamespaceName() { return $this->getStaticReflectionParser()->getNamespaceName(); } /** * {@inheritDoc} */ public function getDocComment() { return $this->getStaticReflectionParser()->getDocComment('method', $this->methodName); } /** * @return string[] */ public function getUseStatements() { return $this->getStaticReflectionParser()->getUseStatements(); } /** * {@inheritDoc} */ public static function export($class, $name, $return = false) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getClosure($object = null) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getModifiers() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getPrototype() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function invoke($object, $parameter = null) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function invokeArgs($object, array $args) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isAbstract() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isConstructor() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isDestructor() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isFinal() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isPrivate() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isProtected() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isPublic() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isStatic() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function setAccessible($accessible) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function __toString() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getClosureThis() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getEndLine() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getExtension() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getExtensionName() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getFileName() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getNumberOfParameters() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getNumberOfRequiredParameters() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getParameters() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getShortName() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getStartLine() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getStaticVariables() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function inNamespace() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isClosure() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isDeprecated() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isInternal() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isUserDefined() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function returnsReference() { throw new ReflectionException('Method not implemented'); } } lib/Doctrine/Common/Reflection/StaticReflectionParser.php000064400000022702144760115550017546 0ustar00 '', 'property' => [], 'method' => [], ]; /** * The name of the class this class extends, if any. * * @var string */ protected $parentClassName = ''; /** * The parent PSR-0 Parser. * * @var \Doctrine\Common\Reflection\StaticReflectionParser */ protected $parentStaticReflectionParser; /** * Parses a class residing in a PSR-0 hierarchy. * * @param string $className The full, namespaced class name. * @param ClassFinderInterface $finder A ClassFinder object which finds the class. * @param bool $classAnnotationOptimize Only retrieve the class docComment. * Presumes there is only one statement per line. */ public function __construct($className, $finder, $classAnnotationOptimize = false) { $this->className = ltrim($className, '\\'); $lastNsPos = strrpos($this->className, '\\'); if ($lastNsPos !== false) { $this->namespace = substr($this->className, 0, $lastNsPos); $this->shortClassName = substr($this->className, $lastNsPos + 1); } else { $this->shortClassName = $this->className; } $this->finder = $finder; $this->classAnnotationOptimize = $classAnnotationOptimize; } /** * @return void */ protected function parse() { $fileName = $this->finder->findFile($this->className); if ($this->parsed || ! $fileName) { return; } $this->parsed = true; $contents = file_get_contents($fileName); if ($this->classAnnotationOptimize) { $regex = sprintf('/\A.*^\s*((abstract|final)\s+)?class\s+%s\s+/sm', $this->shortClassName); if (preg_match($regex, $contents, $matches)) { $contents = $matches[0]; } } $tokenParser = new TokenParser($contents); $docComment = ''; $last_token = false; while ($token = $tokenParser->next(false)) { switch ($token[0]) { case T_USE: $this->useStatements = array_merge($this->useStatements, $tokenParser->parseUseStatement()); break; case T_DOC_COMMENT: $docComment = $token[1]; break; case T_CLASS: if ($last_token !== T_PAAMAYIM_NEKUDOTAYIM && $last_token !== T_NEW) { $this->docComment['class'] = $docComment; $docComment = ''; } break; case T_VAR: case T_PRIVATE: case T_PROTECTED: case T_PUBLIC: $token = $tokenParser->next(); if ($token[0] === T_VARIABLE) { $propertyName = substr($token[1], 1); $this->docComment['property'][$propertyName] = $docComment; continue 2; } if ($token[0] !== T_FUNCTION) { // For example, it can be T_FINAL. continue 2; } // No break. case T_FUNCTION: // The next string after function is the name, but // there can be & before the function name so find the // string. while (($token = $tokenParser->next()) && $token[0] !== T_STRING) { continue; } $methodName = $token[1]; $this->docComment['method'][$methodName] = $docComment; $docComment = ''; break; case T_EXTENDS: $this->parentClassName = $tokenParser->parseClass(); $nsPos = strpos($this->parentClassName, '\\'); $fullySpecified = false; if ($nsPos === 0) { $fullySpecified = true; } else { if ($nsPos) { $prefix = strtolower(substr($this->parentClassName, 0, $nsPos)); $postfix = substr($this->parentClassName, $nsPos); } else { $prefix = strtolower($this->parentClassName); $postfix = ''; } foreach ($this->useStatements as $alias => $use) { if ($alias !== $prefix) { continue; } $this->parentClassName = '\\' . $use . $postfix; $fullySpecified = true; } } if (! $fullySpecified) { $this->parentClassName = '\\' . $this->namespace . '\\' . $this->parentClassName; } break; } $last_token = $token[0]; } } /** * @return StaticReflectionParser */ protected function getParentStaticReflectionParser() { if (empty($this->parentStaticReflectionParser)) { $this->parentStaticReflectionParser = new static($this->parentClassName, $this->finder); } return $this->parentStaticReflectionParser; } /** * @return string */ public function getClassName() { return $this->className; } /** * @return string */ public function getNamespaceName() { return $this->namespace; } /** * {@inheritDoc} */ public function getReflectionClass() { return new StaticReflectionClass($this); } /** * {@inheritDoc} */ public function getReflectionMethod($methodName) { return new StaticReflectionMethod($this, $methodName); } /** * {@inheritDoc} */ public function getReflectionProperty($propertyName) { return new StaticReflectionProperty($this, $propertyName); } /** * Gets the use statements from this file. * * @return string[] */ public function getUseStatements() { $this->parse(); return $this->useStatements; } /** * Gets the doc comment. * * @param string $type The type: 'class', 'property' or 'method'. * @param string $name The name of the property or method, not needed for 'class'. * * @return string The doc comment, empty string if none. */ public function getDocComment($type = 'class', $name = '') { $this->parse(); return $name ? $this->docComment[$type][$name] : $this->docComment[$type]; } /** * Gets the PSR-0 parser for the declaring class. * * @param string $type The type: 'property' or 'method'. * @param string $name The name of the property or method. * * @return StaticReflectionParser A static reflection parser for the declaring class. * * @throws ReflectionException */ public function getStaticReflectionParserForDeclaringClass($type, $name) { $this->parse(); if (isset($this->docComment[$type][$name])) { return $this; } if (! empty($this->parentClassName)) { return $this->getParentStaticReflectionParser()->getStaticReflectionParserForDeclaringClass($type, $name); } throw new ReflectionException('Invalid ' . $type . ' "' . $name . '"'); } } lib/Doctrine/Common/Reflection/StaticReflectionProperty.php000064400000006265144760115550020144 0ustar00staticReflectionParser = $staticReflectionParser; $this->propertyName = $propertyName; } /** * {@inheritDoc} */ public function getName() { return $this->propertyName; } /** * @return StaticReflectionParser */ protected function getStaticReflectionParser() { return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('property', $this->propertyName); } /** * {@inheritDoc} */ public function getDeclaringClass() { return $this->getStaticReflectionParser()->getReflectionClass(); } /** * {@inheritDoc} */ public function getDocComment() { return $this->getStaticReflectionParser()->getDocComment('property', $this->propertyName); } /** * @return string[] */ public function getUseStatements() { return $this->getStaticReflectionParser()->getUseStatements(); } /** * {@inheritDoc} */ public static function export($class, $name, $return = false) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getModifiers() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function getValue($object = null) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isDefault() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isPrivate() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isProtected() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isPublic() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function isStatic() { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function setAccessible($accessible) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function setValue($object, $value = null) { throw new ReflectionException('Method not implemented'); } /** * {@inheritDoc} */ public function __toString() { throw new ReflectionException('Method not implemented'); } } lib/Doctrine/Common/Reflection/TypedNoDefaultReflectionProperty.php000064400000001340144760115550021571 0ustar00isInitialized($object) ? parent::getValue($object) : null; } } phpstan.neon.dist000064400000000523144760115550010054 0ustar00parameters: level: 3 paths: - %rootDir%/../../../lib - %rootDir%/../../../tests ignoreErrors: - '#Doctrine\\Common\\Reflection\\StaticReflection[a-zA-Z0-9_]+::__construct\(\) does not call parent constructor from Reflection[a-zA-Z0-9_]+#' includes: - vendor/phpstan/phpstan-phpunit/extension.neon