Issue #3180351 by longwave, alexpott, daffie, catch, andypost, Charlie ChX... (a0a22f8d) · Commits · project / drupal

core/lib/Drupal/Component/Annotation/Doctrine/Compatibility/Php7/ReflectionClass.php

0 → 100644

+48 −0

Changes for core/lib/Drupal/Component/Annotation/Doctrine/Compatibility/Php7/ReflectionClass.php: 48 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		<?php
		// phpcs:ignoreFile

		/**
		* @file
		*
		* This class is a near-copy of
		* Doctrine\Common\Reflection\Compatibility\Php7\ReflectionClass, which is part
		* of the Doctrine project: <http://www.doctrine-project.org>. It was copied
		* from version 1.2.2.
		*
		* Original copyright:
		*
		* Copyright (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.
		*/

		namespace Drupal\Component\Annotation\Doctrine\Compatibility\Php7;

		use ReflectionException;

		trait ReflectionClass
		{
		/**
		* {@inheritDoc}
		*/
		public function getConstants()
		{
		throw new ReflectionException('Method not implemented');
		}

		/**
		* {@inheritDoc}
		*/
		public function newInstance($args)
		{
		throw new ReflectionException('Method not implemented');
		}
		}

core/lib/Drupal/Component/Annotation/Doctrine/Compatibility/Php8/ReflectionClass.php

0 → 100644

+48 −0

Changes for core/lib/Drupal/Component/Annotation/Doctrine/Compatibility/Php8/ReflectionClass.php: 48 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		<?php
		// phpcs:ignoreFile

		/**
		* @file
		*
		* This class is a near-copy of
		* Doctrine\Common\Reflection\Compatibility\Php8\ReflectionClass, which is part
		* of the Doctrine project: <http://www.doctrine-project.org>. It was copied
		* from version 1.2.2.
		*
		* Original copyright:
		*
		* Copyright (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.
		*/

		namespace Drupal\Component\Annotation\Doctrine\Compatibility\Php8;

		use ReflectionException;

		trait ReflectionClass
		{
		/**
		* {@inheritDoc}
		*/
		public function getConstants(?int $filter = null)
		{
		throw new ReflectionException('Method not implemented');
		}

		/**
		* {@inheritDoc}
		*/
		public function newInstance(mixed ...$args)
		{
		throw new ReflectionException('Method not implemented');
		}
		}

core/lib/Drupal/Component/Annotation/Doctrine/Compatibility/ReflectionClass.php

0 → 100644

+42 −0

Changes for core/lib/Drupal/Component/Annotation/Doctrine/Compatibility/ReflectionClass.php: 42 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		<?php
		// phpcs:ignoreFile

		/**
		* @file
		*
		* This class is a near-copy of
		* Doctrine\Common\Reflection\Compatibility\ReflectionClass, which is part of
		* the Doctrine project: <http://www.doctrine-project.org>. It was copied from
		* version 1.2.2.
		*
		* Original copyright:
		*
		* Copyright (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.
		*/

		namespace Drupal\Component\Annotation\Doctrine\Compatibility;

		use const PHP_VERSION_ID;
		use function class_alias;

		if (PHP_VERSION_ID >= 80000) {
		class_alias('Drupal\Component\Annotation\Doctrine\Compatibility\Php8\ReflectionClass', 'Drupal\Component\Annotation\Doctrine\Compatibility\ReflectionClass');
		} else {
		class_alias('Drupal\Component\Annotation\Doctrine\Compatibility\Php7\ReflectionClass', 'Drupal\Component\Annotation\Doctrine\Compatibility\ReflectionClass');
		}

		if (false) {
		class ReflectionClass
		{
		}
		}

core/lib/Drupal/Component/Annotation/Doctrine/StaticReflectionClass.php

0 → 100644

+424 −0

Changes for core/lib/Drupal/Component/Annotation/Doctrine/StaticReflectionClass.php: 424 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		<?php
		// phpcs:ignoreFile

		/**
		* @file
		*
		* This class is a near-copy of
		* Doctrine\Common\Reflection\StaticReflectionClass, which is part of the
		* Doctrine project: <http://www.doctrine-project.org>. It was copied from
		* version 1.2.2.
		*
		* Original copyright:
		*
		* Copyright (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.
		*/

		namespace Drupal\Component\Annotation\Doctrine;

		use Drupal\Component\Annotation\Doctrine\Compatibility\ReflectionClass as CompatibilityReflectionClass;
		use ReflectionClass;
		use ReflectionException;

		class StaticReflectionClass extends ReflectionClass
		{
		use CompatibilityReflectionClass;

		/**
		* The static reflection parser object.
		*
		* @var StaticReflectionParser
		*/
		private $staticReflectionParser;

		public function __construct(StaticReflectionParser $staticReflectionParser)
		{
		$this->staticReflectionParser = $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)
		{
		throw new ReflectionException('Method not implemented');
		}

		/**
		* {@inheritDoc}
		*/
		public function getProperty($name)
		{
		throw new ReflectionException('Method not implemented');
		}

		/**
		* {@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 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 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');
		}
		}

core/lib/Drupal/Component/Annotation/Doctrine/StaticReflectionParser.php

0 → 100644

+344 −0

Changes for core/lib/Drupal/Component/Annotation/Doctrine/StaticReflectionParser.php: 344 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		<?php
		// phpcs:ignoreFile
		// cspell:ignore paamayim nekudotayim

		/**
		* @file
		*
		* This class is a near-copy of
		* Doctrine\Common\Reflection\StaticReflectionParser, which is part of the
		* Doctrine project: <http://www.doctrine-project.org>. It was copied from
		* version 1.2.2.
		*
		* Original copyright:
		*
		* Copyright (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.
		*/

		namespace Drupal\Component\Annotation\Doctrine;

		use Doctrine\Common\Annotations\TokenParser;
		use ReflectionException;
		use const T_CLASS;
		use const T_DOC_COMMENT;
		use const T_EXTENDS;
		use const T_FUNCTION;
		use const T_NEW;
		use const T_PAAMAYIM_NEKUDOTAYIM;
		use const T_PRIVATE;
		use const T_PROTECTED;
		use const T_PUBLIC;
		use const T_STRING;
		use const T_USE;
		use const T_VAR;
		use const T_VARIABLE;
		use function array_merge;
		use function file_get_contents;
		use function is_array;
		use function ltrim;
		use function preg_match;
		use function sprintf;
		use function strpos;
		use function strrpos;
		use function strtolower;
		use function substr;

		/**
		* Parses a file for namespaces/use/class declarations.
		*/
		class StaticReflectionParser
		{
		/**
		* The fully qualified class name.
		*
		* @var string
		*/
		protected $className;

		/**
		* The short class name.
		*
		* @var string
		*/
		protected $shortClassName;

		/**
		* Whether the caller only wants class annotations.
		*
		* @var bool
		*/
		protected $classAnnotationOptimize;

		/**
		* A ClassFinder object which finds the class.
		*
		* @var ClassFinderInterface
		*/
		protected $finder;

		/**
		* Whether the parser has run.
		*
		* @var bool
		*/
		protected $parsed = false;

		/**
		* The namespace of the class.
		*
		* @var string
		*/
		protected $namespace = '';

		/**
		* The use statements of the class.
		*
		* @var string[]
		*/
		protected $useStatements = [];

		/**
		* The docComment of the class.
		*
		* @var mixed[]
		*/
		protected $docComment = [
		'class' => '',
		'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;
		}
		if ($token === null) {
		break;
		}
		$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 = is_array($token) ? $token[0] : false;
		}
		}

		/**
		* @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;
		}

		/**
		* Gets the ReflectionClass equivalent for this class.
		*
		* @return ReflectionClass
		*/
		public function getReflectionClass()
		{
		return new StaticReflectionClass($this);
		}

		/**
		* 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 . '"');
		}
		}