FM / type

/var/www/vhosts/ihelp.ro/httpdocs/vendor/sebastian/type/src/type/

/var/www/vhosts/ihelp.ro/httpdocs/vendor/sebastian/type/src/type

Name	Size	Mode	Actions
CallableType.php	5103	0644	edit dl rm
FalseType.php	880	0644	edit dl rm
GenericObjectType.php	1073	0644	edit dl rm
IntersectionType.php	2789	0644	edit dl rm
IterableType.php	1893	0644	edit dl rm
MixedType.php	794	0644	edit dl rm
NeverType.php	714	0644	edit dl rm
NullType.php	791	0644	edit dl rm
ObjectType.php	1620	0644	edit dl rm
SimpleType.php	2051	0644	edit dl rm
StaticType.php	1466	0644	edit dl rm
TrueType.php	875	0644	edit dl rm
Type.php	4784	0644	edit dl rm
UnionType.php	2953	0644	edit dl rm
UnknownType.php	779	0644	edit dl rm
VoidType.php	710	0644	edit dl rm

Edit: /var/www/vhosts/ihelp.ro/httpdocs/vendor/sebastian/type/src/type/IntersectionType.php (2789B)

<?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 function count;
use function implode;
use function in_array;
use function sort;

final class IntersectionType extends Type
{
    /**
     * @psalm-var non-empty-list<Type>
     */
    private $types;

/**
     * @throws RuntimeException
     */
    public function __construct(Type ...$types)
    {
        $this->ensureMinimumOfTwoTypes(...$types);
        $this->ensureOnlyValidTypes(...$types);
        $this->ensureNoDuplicateTypes(...$types);

$this->types = $types;
    }

public function isAssignable(Type $other): bool
    {
        return $other->isObject();
    }

public function asString(): string
    {
        return $this->name();
    }

public function name(): string
    {
        $types = [];

foreach ($this->types as $type) {
            $types[] = $type->name();
        }

sort($types);

return implode('&', $types);
    }

public function allowsNull(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true IntersectionType $this
     */
    public function isIntersection(): bool
    {
        return true;
    }

/**
     * @psalm-return non-empty-list<Type>
     */
    public function types(): array
    {
        return $this->types;
    }

/**
     * @throws RuntimeException
     */
    private function ensureMinimumOfTwoTypes(Type ...$types): void
    {
        if (count($types) < 2) {
            throw new RuntimeException(
                'An intersection type must be composed of at least two types'
            );
        }
    }

/**
     * @throws RuntimeException
     */
    private function ensureOnlyValidTypes(Type ...$types): void
    {
        foreach ($types as $type) {
            if (!$type->isObject()) {
                throw new RuntimeException(
                    'An intersection type can only be composed of interfaces and classes'
                );
            }
        }
    }

/**
     * @throws RuntimeException
     */
    private function ensureNoDuplicateTypes(Type ...$types): void
    {
        $names = [];

foreach ($types as $type) {
            assert($type instanceof ObjectType);

$classQualifiedName = $type->className()->qualifiedName();

if (in_array($classQualifiedName, $names, true)) {
                throw new RuntimeException('An intersection type must not contain duplicate types');
            }

$names[] = $classQualifiedName;
        }
    }
}

cmd: