.scrutinizer.yml000064400000001766144760133620007746 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 LICENSE000064400000002051144760133620005555 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.md000064400000001732144760133620006034 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.json000064400000002556144760133620007304 0ustar00{ "name": "doctrine/reflection", "type": "library", "description": "Doctrine Reflection component", "keywords": ["reflection"], "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.9.2", "phpstan/phpstan-phpunit": "^0.9.4", "phpunit/phpunit": "^7.0", "doctrine/coding-standard": "^4.0", "doctrine/common": "^2.8", "squizlabs/php_codesniffer": "^3.0" }, "autoload": { "psr-4": { "Doctrine\\Common\\": "lib/Doctrine/Common" } }, "autoload-dev": { "psr-4": { "Doctrine\\Tests\\": "tests/Doctrine/Tests" } }, "extra": { "branch-alias": { "dev-master": "1.0.x-dev" } } } docs/en/index.rst000064400000001552144760133620007750 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 `_ - Gitter chat room `#doctrine/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.rst000064400000004065144760133620011710 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.rst000064400000000060144760133620010243 0ustar00.. toctree:: :depth: 3 reference/index lib/Doctrine/Common/Reflection/ClassFinderInterface.php000064400000000524144760133620017141 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.php000064400000001210144760133620020542 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.php000064400000017533144760133620017363 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.php000064400000015104144760133620017526 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) { 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.php000064400000022630144760133620017544 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) { $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.php000064400000006265144760133620020142 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'); } } phpstan.neon000064400000000366144760133620007115 0ustar00includes: - vendor/phpstan/phpstan-phpunit/extension.neon parameters: ignoreErrors: - '#Doctrine\\Common\\Reflection\\StaticReflection[a-zA-Z0-9_]+::__construct\(\) does not call parent constructor from Reflection[a-zA-Z0-9_]+#'