LOLCATS

: /var/www/admin.fixgini.com/vendor/sebastian/type/src/ [ drwxr-xr-x ]

Information Server

System: Linux vmi1836763.contaboserver.net 5.15.0-130-generic #140-Ubuntu SMP Wed Dec 18 17:59:53 UTC 2024 x86_64
Software: Apache/2.4.52 (Ubuntu)
PHP Version: 8.4.10 PHP Os: Linux
Server IP: 77.237.233.165
Your IP: 10.8.20.41
User: www-data [33] | Group: [www-data] [33]
Safe Mode: OFF
MYSQL: OFF | PERL: ON | PYTHON: ON | WGET: ON | CURL: ON | GCC: ON | PKEXEC: ON
Disable Function:

NONE

Command ON Config Searcher Create RDP Find Modified Time Find File Get Tools GSocket Jumping Lock File Mass Deface Mass Delete Mass Chmod Mass Change Date Port Scan Reverse Shell Upload Zone-H

: ReflectionMapper.php

<?php declare(strict_types=1);
/*
 * This file is part of sebastian/type.
 *
 * (c) Sebastian Bergmann <sebastian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace SebastianBergmann\Type;

use function assert;
use ReflectionFunction;
use ReflectionIntersectionType;
use ReflectionMethod;
use ReflectionNamedType;
use ReflectionProperty;
use ReflectionType;
use ReflectionUnionType;

/**
 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for this library
 */
final class ReflectionMapper
{
    /**
     * @return list<Parameter>
     */
    public function fromParameterTypes(ReflectionFunction|ReflectionMethod $reflector): array
    {
        $parameters = [];

foreach ($reflector->getParameters() as $parameter) {
            $name = $parameter->getName();

assert($name !== '');

if (!$parameter->hasType()) {
                $parameters[] = new Parameter($name, new UnknownType);

continue;
            }

$type = $parameter->getType();

if ($type instanceof ReflectionNamedType) {
                $parameters[] = new Parameter(
                    $name,
                    $this->mapNamedType($type, $reflector),
                );

continue;
            }

if ($type instanceof ReflectionUnionType) {
                $parameters[] = new Parameter(
                    $name,
                    $this->mapUnionType($type, $reflector),
                );

continue;
            }

if ($type instanceof ReflectionIntersectionType) {
                $parameters[] = new Parameter(
                    $name,
                    $this->mapIntersectionType($type, $reflector),
                );
            }
        }

return $parameters;
    }

public function fromReturnType(ReflectionFunction|ReflectionMethod $reflector): Type
    {
        if (!$this->hasReturnType($reflector)) {
            return new UnknownType;
        }

$returnType = $this->returnType($reflector);

assert($returnType instanceof ReflectionNamedType || $returnType instanceof ReflectionUnionType || $returnType instanceof ReflectionIntersectionType);

if ($returnType instanceof ReflectionNamedType) {
            return $this->mapNamedType($returnType, $reflector);
        }

if ($returnType instanceof ReflectionUnionType) {
            return $this->mapUnionType($returnType, $reflector);
        }

if ($returnType instanceof ReflectionIntersectionType) {
            return $this->mapIntersectionType($returnType, $reflector);
        }
    }

public function fromPropertyType(ReflectionProperty $reflector): Type
    {
        if (!$reflector->hasType()) {
            return new UnknownType;
        }

$propertyType = $reflector->getType();

assert($propertyType instanceof ReflectionNamedType || $propertyType instanceof ReflectionUnionType || $propertyType instanceof ReflectionIntersectionType);

if ($propertyType instanceof ReflectionNamedType) {
            return $this->mapNamedType($propertyType, $reflector);
        }

if ($propertyType instanceof ReflectionUnionType) {
            return $this->mapUnionType($propertyType, $reflector);
        }

if ($propertyType instanceof ReflectionIntersectionType) {
            return $this->mapIntersectionType($propertyType, $reflector);
        }
    }

private function mapNamedType(ReflectionNamedType $type, ReflectionFunction|ReflectionMethod|ReflectionProperty $reflector): Type
    {
        $classScope = !$reflector instanceof ReflectionFunction;

if ($classScope && $type->getName() === 'self') {
            return ObjectType::fromName(
                $reflector->getDeclaringClass()->getName(),
                $type->allowsNull(),
            );
        }

if ($classScope && $type->getName() === 'static') {
            return new StaticType(
                TypeName::fromReflection($reflector->getDeclaringClass()),
                $type->allowsNull(),
            );
        }

if ($type->getName() === 'mixed') {
            return new MixedType;
        }

if ($classScope && $type->getName() === 'parent') {
            return ObjectType::fromName(
                $reflector->getDeclaringClass()->getParentClass()->getName(),
                $type->allowsNull(),
            );
        }

return Type::fromName(
            $type->getName(),
            $type->allowsNull(),
        );
    }

private function mapUnionType(ReflectionUnionType $type, ReflectionFunction|ReflectionMethod|ReflectionProperty $reflector): Type
    {
        $types = [];

foreach ($type->getTypes() as $_type) {
            if ($_type instanceof ReflectionNamedType) {
                $types[] = $this->mapNamedType($_type, $reflector);

continue;
            }

$types[] = $this->mapIntersectionType($_type, $reflector);
        }

return new UnionType(...$types);
    }

private function mapIntersectionType(ReflectionIntersectionType $type, ReflectionFunction|ReflectionMethod|ReflectionProperty $reflector): Type
    {
        $types = [];

foreach ($type->getTypes() as $_type) {
            assert($_type instanceof ReflectionNamedType);

$types[] = $this->mapNamedType($_type, $reflector);
        }

return new IntersectionType(...$types);
    }

private function hasReturnType(ReflectionFunction|ReflectionMethod $reflector): bool
    {
        if ($reflector->hasReturnType()) {
            return true;
        }

return $reflector->hasTentativeReturnType();
    }

private function returnType(ReflectionFunction|ReflectionMethod $reflector): ?ReflectionType
    {
        if ($reflector->hasReturnType()) {
            return $reflector->getReturnType();
        }

return $reflector->getTentativeReturnType();
    }
}

NAME	TYPE	LAST MODIFIED	SIZE	OWNER / GROUP	PERMISSIONS	ACTION
..
Parameter.php	f!le	2024-09-17 13:12	923 B	root / root	-rw-r--r--
ReflectionMapper.php	f!le	2024-09-17 13:12	5.96 KB	root / root	-rw-r--r--
TypeName.php	f!le	2024-09-17 13:12	2.31 KB	root / root	-rw-r--r--