Subversion-Projekte lars-tiefland.laravel_shop

<?php

declare(strict_types=1);

/**

 * This file is part of the Carbon package.

 *

 * (c) Brian Nesbitt <brian@nesbot.com>

 *

 * For the full copyright and license information, please view the LICENSE

 * file that was distributed with this source code.

 */

namespace Carbon\PHPStan;

use Closure;

use InvalidArgumentException;

use PHPStan\BetterReflection\Reflection\Adapter\ReflectionParameter as AdapterReflectionParameter;

use PHPStan\BetterReflection\Reflection\Adapter\ReflectionType as AdapterReflectionType;

use PHPStan\BetterReflection\Reflection\ReflectionClass as BetterReflectionClass;

use PHPStan\BetterReflection\Reflection\ReflectionFunction as BetterReflectionFunction;

use PHPStan\BetterReflection\Reflection\ReflectionParameter as BetterReflectionParameter;

use PHPStan\Reflection\Php\BuiltinMethodReflection;

use PHPStan\TrinaryLogic;

use ReflectionClass;

use ReflectionFunction;

use ReflectionMethod;

use ReflectionParameter;

use ReflectionType;

use stdClass;

use Throwable;

abstract class AbstractMacro implements BuiltinMethodReflection

{

    /**

     * The reflection function/method.

     *

     * @var ReflectionFunction|ReflectionMethod

     */

    protected $reflectionFunction;

    /**

     * The class name.

     *

     * @var class-string

     */

    private $className;

    /**

     * The method name.

     *

     * @var string

     */

    private $methodName;

    /**

     * The parameters.

     *

     * @var ReflectionParameter[]

     */

    private $parameters;

    /**

     * The is static.

     *

     * @var bool

     */

    private $static = false;

    /**

     * Macro constructor.

     *

     * @param string $className

     * @phpstan-param class-string $className

     *

     * @param string   $methodName

     * @param callable $macro

     */

    public function __construct(string $className, string $methodName, $macro)

    {

        $this->className = $className;

        $this->methodName = $methodName;

        $rawReflectionFunction = \is_array($macro)

            ? new ReflectionMethod($macro[0], $macro[1])

            : new ReflectionFunction($macro);

        $this->reflectionFunction = self::hasModernParser()

            ? $this->getReflectionFunction($macro)

            : $rawReflectionFunction; // @codeCoverageIgnore

        $this->parameters = array_map(

            function ($parameter) {

                if ($parameter instanceof BetterReflectionParameter) {

                    return new AdapterReflectionParameter($parameter);

                }

                return $parameter; // @codeCoverageIgnore

            },

            $this->reflectionFunction->getParameters()

        );

        if ($rawReflectionFunction->isClosure()) {

            try {

                $closure = $rawReflectionFunction->getClosure();

                $boundClosure = Closure::bind($closure, new stdClass());

                $this->static = (!$boundClosure || (new ReflectionFunction($boundClosure))->getClosureThis() === null);

            } catch (Throwable $e) {

                $this->static = true;

            }

        }

    }

    private function getReflectionFunction($spec)

    {

        if (\is_array($spec) && \count($spec) === 2 && \is_string($spec[1])) {

            \assert($spec[1] !== '');

            if (\is_object($spec[0])) {

                return BetterReflectionClass::createFromInstance($spec[0])

                    ->getMethod($spec[1]);

            }

            return BetterReflectionClass::createFromName($spec[0])

                ->getMethod($spec[1]);

        }

        if (\is_string($spec)) {

            return BetterReflectionFunction::createFromName($spec);

        }

        if ($spec instanceof Closure) {

            return BetterReflectionFunction::createFromClosure($spec);

        }

        throw new InvalidArgumentException('Could not create reflection from the spec given'); // @codeCoverageIgnore

    }

    /**

     * {@inheritdoc}

     */

    public function getDeclaringClass(): ReflectionClass

    {

        return new ReflectionClass($this->className);

    }

    /**

     * {@inheritdoc}

     */

    public function isPrivate(): bool

    {

        return false;

    }

    /**

     * {@inheritdoc}

     */

    public function isPublic(): bool

    {

        return true;

    }

    /**

     * {@inheritdoc}

     */

    public function isFinal(): bool

    {

        return false;

    }

    /**

     * {@inheritdoc}

     */

    public function isInternal(): bool

    {

        return false;

    }

    /**

     * {@inheritdoc}

     */

    public function isAbstract(): bool

    {

        return false;

    }

    /**

     * {@inheritdoc}

     */

    public function isStatic(): bool

    {

        return $this->static;

    }

    /**

     * {@inheritdoc}

     */

    public function getDocComment(): ?string

    {

        return $this->reflectionFunction->getDocComment() ?: null;

    }

    /**

     * {@inheritdoc}

     */

    public function getName(): string

    {

        return $this->methodName;

    }

    /**

     * {@inheritdoc}

     */

    public function getParameters(): array

    {

        return $this->parameters;

    }

    /**

     * {@inheritdoc}

     */

    public function getReturnType(): ?ReflectionType

    {

        $type = $this->reflectionFunction->getReturnType();

        if ($type instanceof ReflectionType) {

            return $type; // @codeCoverageIgnore

        }

        return self::adaptType($type);

    }

    /**

     * {@inheritdoc}

     */

    public function isDeprecated(): TrinaryLogic

    {

        return TrinaryLogic::createFromBoolean(

            $this->reflectionFunction->isDeprecated() ||

            preg_match('/@deprecated/i', $this->getDocComment() ?: '')

        );

    }

    /**

     * {@inheritdoc}

     */

    public function isVariadic(): bool

    {

        return $this->reflectionFunction->isVariadic();

    }

    /**

     * {@inheritdoc}

     */

    public function getPrototype(): BuiltinMethodReflection

    {

        return $this;

    }

    public function getTentativeReturnType(): ?ReflectionType

    {

        return null;

    }

    public function returnsByReference(): TrinaryLogic

    {

        return TrinaryLogic::createNo();

    }

    private static function adaptType($type)

    {

        $method = method_exists(AdapterReflectionType::class, 'fromTypeOrNull')

            ? 'fromTypeOrNull'

            : 'fromReturnTypeOrNull'; // @codeCoverageIgnore

        return AdapterReflectionType::$method($type);

    }

    private static function hasModernParser(): bool

    {

        static $modernParser = null;

        if ($modernParser !== null) {

            return $modernParser;

        }

        $modernParser = method_exists(AdapterReflectionType::class, 'fromTypeOrNull');

        return $modernParser;

    }

}