IntersectionTypeTest.php

<?php declare(strict_types = 1);

namespace PHPStan\Type;

use DateTimeImmutable;
use DateTimeInterface;
use DoctrineIntersectionTypeIsSupertypeOf\Collection;
use Iterator;
use ObjectTypeEnums\FooEnum;
use PHPStan\Analyser\OutOfClassScope;
use PHPStan\DependencyInjection\BleedingEdgeToggle;
use PHPStan\Testing\PHPStanTestCase;
use PHPStan\TrinaryLogic;
use PHPStan\Type\Accessory\AccessoryArrayListType;
use PHPStan\Type\Accessory\AccessoryDecimalIntegerStringType;
use PHPStan\Type\Accessory\AccessoryLowercaseStringType;
use PHPStan\Type\Accessory\AccessoryUppercaseStringType;
use PHPStan\Type\Accessory\HasOffsetType;
use PHPStan\Type\Accessory\HasOffsetValueType;
use PHPStan\Type\Accessory\HasPropertyType;
use PHPStan\Type\Accessory\NonEmptyArrayType;
use PHPStan\Type\Accessory\OversizedArrayType;
use PHPStan\Type\Constant\ConstantArrayType;
use PHPStan\Type\Constant\ConstantBooleanType;
use PHPStan\Type\Constant\ConstantFloatType;
use PHPStan\Type\Constant\ConstantIntegerType;
use PHPStan\Type\Constant\ConstantStringType;
use PHPStan\Type\Enum\EnumCaseObjectType;
use PHPStan\Type\Generic\TemplateTypeFactory;
use PHPStan\Type\Generic\TemplateTypeScope;
use PHPStan\Type\Generic\TemplateTypeVariance;
use PHPUnit\Framework\Attributes\DataProvider;
use stdClass;
use Test\ClassWithToString;
use Traversable;
use function array_map;
use function count;
use function sprintf;
use const PHP_INT_MAX;
use const PHP_VERSION_ID;

class IntersectionTypeTest extends PHPStanTestCase
{

	/**
	 * @return Iterator<int, array{Type, Type, TrinaryLogic}>
	 */
	public static function dataAccepts(): Iterator
	{
		$intersectionType = new IntersectionType([
			new ObjectType('Collection'),
			new IterableType(new MixedType(), new ObjectType('Item')),
		]);

		yield [
			$intersectionType,
			$intersectionType,
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionType,
			new ObjectType('Collection'),
			TrinaryLogic::createNo(),
		];

		yield [
			$intersectionType,
			new IterableType(new MixedType(), new ObjectType('Item')),
			TrinaryLogic::createMaybe(),
		];

		yield [
			new IntersectionType([
				new ObjectType(ClassWithToString::class),
				new HasPropertyType('foo'),
			]),
			new StringType(),
			TrinaryLogic::createNo(),
		];

		yield [
			TypeCombinator::intersect(new ArrayType(new MixedType(), new MixedType()), new CallableType()),
			new CallableType(),
			TrinaryLogic::createMaybe(),
		];

		yield [
			TypeCombinator::intersect(
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
			),
			TypeCombinator::intersect(
				new ArrayType(new MixedType(), new MixedType()),
				new HasOffsetType(new ConstantStringType('some-key')),
			),
			TrinaryLogic::createYes(),
		];

		yield [
			TypeCombinator::intersect(
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
			),
			TypeCombinator::intersect(
				new ArrayType(new MixedType(), new MixedType()),
				new HasOffsetValueType(new ConstantStringType('some-key'), new IntegerType()),
			),
			TrinaryLogic::createYes(),
		];
	}

	#[DataProvider('dataAccepts')]
	public function testAccepts(Type $type, Type $otherType, TrinaryLogic $expectedResult): void
	{
		$actualResult = $type->accepts($otherType, true)->result;
		$this->assertSame(
			$expectedResult->describe(),
			$actualResult->describe(),
			sprintf('%s -> accepts(%s)', $type->describe(VerbosityLevel::precise()), $otherType->describe(VerbosityLevel::precise())),
		);
	}

	/**
	 * @return Iterator<int, array{Type, Type, TrinaryLogic}>
	 */
	public static function dataIsAcceptedBy(): Iterator
	{
		// array&callable isAcceptedBy array - success
		yield [
			new IntersectionType([new ArrayType(new MixedType(), new MixedType()), new CallableType()]),
			new ArrayType(new MixedType(), new MixedType()),
			TrinaryLogic::createYes(),
		];

		// array&callable isAcceptedBy array<int> - failure
		yield [
			new IntersectionType([new ArrayType(new MixedType(), new MixedType()), new CallableType()]),
			new ArrayType(new MixedType(), new IntegerType()),
			TrinaryLogic::createNo(),
		];

		// array&callable isAcceptedBy constantArray{stdClass, string} - maybe
		yield [
			new IntersectionType([new ArrayType(new MixedType(), new MixedType()), new CallableType()]),
			BleedingEdgeToggle::withBleedingEdge(false, static fn (): ConstantArrayType => new ConstantArrayType(
				[new ConstantIntegerType(0), new ConstantIntegerType(1)],
				[new UnionType([new ObjectType('stdClass'), new StringType()]), new StringType()],
			)),
			TrinaryLogic::createMaybe(),
		];

		// array&callable isAcceptedBy constantArray{string, string} - maybe
		yield [
			new IntersectionType([new ArrayType(new MixedType(), new MixedType()), new CallableType()]),
			BleedingEdgeToggle::withBleedingEdge(false, static fn (): ConstantArrayType => new ConstantArrayType(
				[new ConstantIntegerType(0), new ConstantIntegerType(1)],
				[new StringType(), new StringType()],
			)),
			TrinaryLogic::createMaybe(),
		];

		// array&hasOffsetValue isAcceptedBy array - success
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(3), new IntegerType()),
			]),
			new ArrayType(new MixedType(), new MixedType()),
			TrinaryLogic::createYes(),
		];

		// array&hasOffsetValue isAcceptedBy array - failure
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(3), new IntegerType()),
			]),
			new ArrayType(new MixedType(), new StringType()),
			TrinaryLogic::createNo(),
		];

		// array&hasOffsetValue isAcceptedBy array<int> - success (matching value type)
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(3), new IntegerType()),
			]),
			new ArrayType(new MixedType(), new IntegerType()),
			TrinaryLogic::createYes(),
		];

		// array&hasOffsetValue isAcceptedBy constantArray{int, int} - success
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(0), new IntegerType()),
			]),
			BleedingEdgeToggle::withBleedingEdge(false, static fn (): ConstantArrayType => new ConstantArrayType(
				[new ConstantIntegerType(0), new ConstantIntegerType(1)],
				[new IntegerType(), new IntegerType()],
			)),
			TrinaryLogic::createMaybe(),
		];

		// array&hasOffsetValue isAcceptedBy constantArray{string, string} - failure
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(0), new IntegerType()),
			]),
			BleedingEdgeToggle::withBleedingEdge(false, static fn (): ConstantArrayType => new ConstantArrayType(
				[new ConstantIntegerType(0), new ConstantIntegerType(1)],
				[new StringType(), new StringType()],
			)),
			TrinaryLogic::createNo(),
		];

		// array&hasOffsetValue(3, int) isAcceptedBy array<int>|array<string> - yes (array<int> accepts it)
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(3), new IntegerType()),
			]),
			new UnionType([
				new ArrayType(new MixedType(), new IntegerType()),
				new ArrayType(new MixedType(), new StringType()),
			]),
			TrinaryLogic::createYes(),
		];
	}

	#[DataProvider('dataIsAcceptedBy')]
	public function testIsAcceptedBy(Type $type, Type $acceptingType, TrinaryLogic $expectedResult): void
	{
		$actualResult = $acceptingType->accepts($type, true)->result;
		$this->assertSame(
			$expectedResult->describe(),
			$actualResult->describe(),
			sprintf('%s -> isAcceptedBy(%s)', $type->describe(VerbosityLevel::precise()), $acceptingType->describe(VerbosityLevel::precise())),
		);
	}

	public static function dataIsCallable(): array
	{
		return [
			[
				new IntersectionType([
					new ConstantArrayType(
						[new ConstantIntegerType(0), new ConstantIntegerType(1)],
						[new ConstantStringType('Closure'), new ConstantStringType('bind')],
					),
					new IterableType(new MixedType(), new ObjectType('Item')),
				]),
				TrinaryLogic::createYes(),
			],
			[
				new IntersectionType([
					new ArrayType(new MixedType(), new MixedType()),
					new IterableType(new MixedType(), new ObjectType('Item')),
				]),
				TrinaryLogic::createMaybe(),
			],
			[
				new IntersectionType([
					new ObjectType('ArrayObject'),
					new IterableType(new MixedType(), new ObjectType('Item')),
				]),
				TrinaryLogic::createMaybe(),
			],
		];
	}

	#[DataProvider('dataIsCallable')]
	public function testIsCallable(IntersectionType $type, TrinaryLogic $expectedResult): void
	{
		$actualResult = $type->isCallable();
		$this->assertSame(
			$expectedResult->describe(),
			$actualResult->describe(),
			sprintf('%s -> isCallable()', $type->describe(VerbosityLevel::precise())),
		);
	}

	/**
	 * @return Iterator<int, array{IntersectionType, Type, TrinaryLogic}>
	 */
	public static function dataIsSuperTypeOf(): Iterator
	{
		$intersectionTypeA = new IntersectionType([
			new ObjectType('ArrayObject'),
			new IterableType(new MixedType(), new ObjectType('Item')),
		]);

		yield [
			$intersectionTypeA,
			$intersectionTypeA,
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionTypeA,
			new ObjectType('ArrayObject'),
			TrinaryLogic::createMaybe(),
		];

		yield [
			$intersectionTypeA,
			new IterableType(new MixedType(), new ObjectType('Item')),
			TrinaryLogic::createMaybe(),
		];

		yield [
			$intersectionTypeA,
			new ArrayType(new MixedType(), new ObjectType('Item')),
			TrinaryLogic::createNo(),
		];

		yield [
			new IntersectionType([
				new ObjectType(Traversable::class),
				new IterableType(new MixedType(true), new ObjectType(stdClass::class)),
			]),
			new IntersectionType([
				new ObjectType(Traversable::class),
				new IterableType(new MixedType(true), new ObjectType(stdClass::class)),
			]),
			TrinaryLogic::createYes(),
		];

		yield [
			new IntersectionType([
				new ObjectType(Collection::class),
				new IterableType(new MixedType(true), new ObjectType(stdClass::class)),
			]),
			new IntersectionType([
				new ObjectType(Collection::class),
				new IterableType(new MixedType(true), new ObjectType(stdClass::class)),
			]),
			TrinaryLogic::createYes(),
		];

		yield [
			new IntersectionType([
				new ObjectType(\TestIntersectionTypeIsSupertypeOf\Collection::class),
				new IterableType(new MixedType(true), new ObjectType(stdClass::class)),
			]),
			new IntersectionType([
				new ObjectType(\TestIntersectionTypeIsSupertypeOf\Collection::class),
				new IterableType(new MixedType(true), new ObjectType(stdClass::class)),
			]),
			TrinaryLogic::createYes(),
		];

		yield [
			new IntersectionType([
				new ObjectType(Collection::class),
				new IterableType(new MixedType(true), new ObjectType(stdClass::class)),
			]),
			new IntersectionType([
				new ObjectType(Collection::class),
				new IterableType(new MixedType(), new ObjectType(stdClass::class)),
			]),
			TrinaryLogic::createYes(),
		];

		yield [
			new IntersectionType([
				new ObjectType(Collection::class),
				new IterableType(new MixedType(), new ObjectType(stdClass::class)),
			]),
			new IntersectionType([
				new ObjectType(Collection::class),
				new IterableType(new MixedType(true), new ObjectType(stdClass::class)),
			]),
			TrinaryLogic::createYes(),
		];

		yield [
			new IntersectionType([
				new ObjectType(Collection::class),
				new IterableType(new MixedType(), new ObjectType(stdClass::class)),
			]),
			new IntersectionType([
				new ObjectType(Collection::class),
				new IterableType(new MixedType(), new ObjectType(stdClass::class)),
			]),
			TrinaryLogic::createYes(),
		];

		yield [
			new IntersectionType([new ArrayType(new IntegerType(), new StringType()), new OversizedArrayType()]),
			new ArrayType(new IntegerType(), new StringType()),
			TrinaryLogic::createMaybe(),
		];
	}

	#[DataProvider('dataIsSuperTypeOf')]
	public function testIsSuperTypeOf(IntersectionType $type, Type $otherType, TrinaryLogic $expectedResult): void
	{
		$actualResult = $type->isSuperTypeOf($otherType);
		$this->assertSame(
			$expectedResult->describe(),
			$actualResult->describe(),
			sprintf('%s -> isSuperTypeOf(%s)', $type->describe(VerbosityLevel::precise()), $otherType->describe(VerbosityLevel::precise())),
		);
	}

	/**
	 * @return Iterator<int, array{IntersectionType, Type, TrinaryLogic}>
	 */
	public static function dataIsSubTypeOf(): Iterator
	{
		$intersectionTypeA = new IntersectionType([
			new ObjectType('ArrayObject'),
			new IterableType(new MixedType(), new ObjectType('Item')),
		]);

		yield [
			$intersectionTypeA,
			$intersectionTypeA,
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionTypeA,
			new ObjectType('ArrayObject'),
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionTypeA,
			new IterableType(new MixedType(), new ObjectType('Item')),
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionTypeA,
			new MixedType(),
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionTypeA,
			new IterableType(new MixedType(), new ObjectType('Unknown')),
			TrinaryLogic::createMaybe(),
		];

		yield [
			$intersectionTypeA,
			new ArrayType(new MixedType(), new ObjectType('Item')),
			TrinaryLogic::createNo(),
		];

		$intersectionTypeC = new IntersectionType([
			new StringType(),
			new CallableType(),
		]);

		yield [
			$intersectionTypeC,
			$intersectionTypeC,
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionTypeC,
			new StringType(),
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionTypeC,
			new UnionType([new IntegerType(), new StringType()]),
			TrinaryLogic::createYes(),
		];

		$intersectionTypeD = new IntersectionType([
			new ObjectType('ArrayObject'),
			new IterableType(new MixedType(), new ObjectType('DatePeriod')),
		]);

		yield [
			$intersectionTypeD,
			$intersectionTypeD,
			TrinaryLogic::createYes(),
		];

		yield [
			$intersectionTypeD,
			new UnionType([
				$intersectionTypeD,
				new IntegerType(),
			]),
			TrinaryLogic::createYes(),
		];

		// array&callable isSubTypeOf array - success
		yield [
			new IntersectionType([new ArrayType(new MixedType(), new MixedType()), new CallableType()]),
			new ArrayType(new MixedType(), new MixedType()),
			TrinaryLogic::createYes(),
		];

		// array&callable isSubTypeOf array<int> - failure
		yield [
			new IntersectionType([new ArrayType(new MixedType(), new MixedType()), new CallableType()]),
			new ArrayType(new MixedType(), new IntegerType()),
			TrinaryLogic::createNo(),
		];

		// array&hasOffsetValue isSubTypeOf array - success
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(3), new IntegerType()),
			]),
			new ArrayType(new MixedType(), new MixedType()),
			TrinaryLogic::createYes(),
		];

		// array&hasOffsetValue isSubTypeOf array<int> - maybe
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(3), new IntegerType()),
			]),
			new ArrayType(new MixedType(), new IntegerType()),
			TrinaryLogic::createMaybe(),
		];

		// array&hasOffsetValue isSubTypeOf array<string> - failure
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
				new HasOffsetValueType(new ConstantIntegerType(3), new IntegerType()),
			]),
			new ArrayType(new MixedType(), new StringType()),
			TrinaryLogic::createNo(),
		];
	}

	#[DataProvider('dataIsSubTypeOf')]
	public function testIsSubTypeOf(IntersectionType $type, Type $otherType, TrinaryLogic $expectedResult): void
	{
		$actualResult = $type->isSubTypeOf($otherType);
		$this->assertSame(
			$expectedResult->describe(),
			$actualResult->describe(),
			sprintf('%s -> isSubTypeOf(%s)', $type->describe(VerbosityLevel::precise()), $otherType->describe(VerbosityLevel::precise())),
		);
	}

	#[DataProvider('dataIsSubTypeOf')]
	public function testIsSubTypeOfInversed(IntersectionType $type, Type $otherType, TrinaryLogic $expectedResult): void
	{
		$actualResult = $otherType->isSuperTypeOf($type);
		$this->assertSame(
			$expectedResult->describe(),
			$actualResult->describe(),
			sprintf('%s -> isSuperTypeOf(%s)', $otherType->describe(VerbosityLevel::precise()), $type->describe(VerbosityLevel::precise())),
		);
	}

	public function testToBooleanCrash(): void
	{
		$type = new IntersectionType([new NeverType(), new NonEmptyArrayType()]);
		$this->assertSame('true', $type->toBoolean()->describe(VerbosityLevel::precise()));
	}

	public static function dataGetEnumCases(): iterable
	{
		if (PHP_VERSION_ID < 80100) {
			return [];
		}

		$reflectionProvider = self::createReflectionProvider();
		$classReflection = $reflectionProvider->getClass(FooEnum::class);

		yield [
			new IntersectionType([
				new ThisType($classReflection),
				new EnumCaseObjectType(FooEnum::class, 'FOO'),
			]),
			[
				new EnumCaseObjectType(FooEnum::class, 'FOO'),
			],
		];
	}

	/**
	 * @param list<EnumCaseObjectType> $expectedEnumCases
	 */
	#[DataProvider('dataGetEnumCases')]
	public function testGetEnumCases(
		IntersectionType $type,
		array $expectedEnumCases,
	): void
	{
		$enumCases = $type->getEnumCases();
		$this->assertCount(count($expectedEnumCases), $enumCases);
		foreach ($enumCases as $i => $enumCase) {
			$expectedEnumCase = $expectedEnumCases[$i];
			$this->assertTrue($expectedEnumCase->equals($enumCase), sprintf('%s->equals(%s)', $expectedEnumCase->describe(VerbosityLevel::precise()), $enumCase->describe(VerbosityLevel::precise())));
		}
	}

	public static function dataDescribe(): iterable
	{
		yield [
			new IntersectionType([new StringType(), new AccessoryLowercaseStringType()]),
			VerbosityLevel::typeOnly(),
			'string',
		];
		yield [
			new IntersectionType([new StringType(), new AccessoryLowercaseStringType()]),
			VerbosityLevel::value(),
			'string',
		];
		yield [
			new IntersectionType([new StringType(), new AccessoryLowercaseStringType()]),
			VerbosityLevel::precise(),
			'lowercase-string',
		];
		yield [
			new IntersectionType([
				new ArrayType(IntegerRangeType::createAllGreaterThanOrEqualTo(0), new MixedType()),
				new AccessoryArrayListType(),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::typeOnly(),
			'list',
		];
		yield [
			new IntersectionType([
				new ArrayType(IntegerRangeType::createAllGreaterThanOrEqualTo(0), new MixedType()),
				new AccessoryArrayListType(),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-list',
		];

		yield [
			new IntersectionType([
				new ArrayType(IntegerRangeType::createAllGreaterThanOrEqualTo(0), new IntegerType()),
				new AccessoryArrayListType(),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::typeOnly(),
			'list<int>',
		];
		yield [
			new IntersectionType([
				new ArrayType(IntegerRangeType::createAllGreaterThanOrEqualTo(0), new IntegerType()),
				new AccessoryArrayListType(),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-list<int>',
		];

		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::typeOnly(),
			'array',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-array',
		];

		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new IntegerType()),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::typeOnly(),
			'array<int>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new IntegerType()),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-array<int>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new IntegerType()),
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::typeOnly(),
			'list<int>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new IntegerType()),
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::value(),
			'list<int>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::typeOnly(),
			'list',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::value(),
			'list',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType(true)),
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::typeOnly(),
			'list<mixed>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType(true)),
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::value(),
			'list<mixed>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new AccessoryArrayListType(),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::typeOnly(),
			'list',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new AccessoryArrayListType(),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-list',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType(true)),
				new AccessoryArrayListType(),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::typeOnly(),
			'list<mixed>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType(true)),
				new AccessoryArrayListType(),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-list<mixed>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::typeOnly(),
			'array',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType()),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-array',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType(true)),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::typeOnly(),
			'array<mixed>',
		];
		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType(true)),
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-array<mixed>',
		];

		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType(true)),
				new NonEmptyArrayType(),
				new OversizedArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-array<mixed>',
		];

		yield [
			new IntersectionType([
				new ArrayType(new MixedType(), new MixedType(true)),
				new NonEmptyArrayType(),
				new OversizedArrayType(),
			]),
			VerbosityLevel::precise(),
			'non-empty-array<mixed>&oversized-array',
		];

		$constantArrayWithOptionalKeys = new ConstantArrayType([
			new ConstantIntegerType(0),
			new ConstantIntegerType(1),
			new ConstantIntegerType(2),
			new ConstantIntegerType(3),
		], [
			new StringType(),
			new StringType(),
			new StringType(),
			new StringType(),
		], [3], [2, 3], TrinaryLogic::createMaybe());

		yield [
			new IntersectionType([
				$constantArrayWithOptionalKeys,
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::typeOnly(),
			'list<string>',
		];

		yield [
			new IntersectionType([
				$constantArrayWithOptionalKeys,
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::value(),
			'list{0: string, 1: string, 2?: string, 3?: string}',
		];

		yield [
			new IntersectionType([
				$constantArrayWithOptionalKeys,
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::precise(),
			'list{0: string, 1: string, 2?: string, 3?: string}',
		];

		$constantArrayWithAllOptionalKeys = new ConstantArrayType([
			new ConstantIntegerType(0),
			new ConstantIntegerType(1),
			new ConstantIntegerType(2),
			new ConstantIntegerType(3),
		], [
			new StringType(),
			new StringType(),
			new StringType(),
			new StringType(),
		], [3], [0, 1, 2, 3], TrinaryLogic::createMaybe());

		yield [
			new IntersectionType([
				$constantArrayWithAllOptionalKeys,
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::value(),
			'list{0?: string, 1?: string, 2?: string, 3?: string}',
		];

		yield [
			new IntersectionType([
				$constantArrayWithAllOptionalKeys,
				new NonEmptyArrayType(),
				new AccessoryArrayListType(),
			]),
			VerbosityLevel::value(),
			'non-empty-list{0?: string, 1?: string, 2?: string, 3?: string}',
		];

		yield [
			new IntersectionType([
				$constantArrayWithAllOptionalKeys,
				new NonEmptyArrayType(),
			]),
			VerbosityLevel::value(),
			'non-empty-array{0?: string, 1?: string, 2?: string, 3?: string}',
		];
		yield [
			new IntersectionType([new StringType(), new AccessoryUppercaseStringType()]),
			VerbosityLevel::typeOnly(),
			'string',
		];
		yield [
			new IntersectionType([new StringType(), new AccessoryUppercaseStringType()]),
			VerbosityLevel::value(),
			'string',
		];
		yield [
			new IntersectionType([new StringType(), new AccessoryUppercaseStringType()]),
			VerbosityLevel::precise(),
			'uppercase-string',
		];

		yield [
			new IntersectionType([new StringType(), new AccessoryDecimalIntegerStringType()]),
			VerbosityLevel::typeOnly(),
			'string',
		];

		yield [
			new IntersectionType([new StringType(), new AccessoryDecimalIntegerStringType(inverse: true)]),
			VerbosityLevel::typeOnly(),
			'string',
		];

		yield [
			new IntersectionType([new StringType(), new AccessoryDecimalIntegerStringType()]),
			VerbosityLevel::value(),
			'decimal-int-string',
		];

		yield [
			new IntersectionType([new StringType(), new AccessoryDecimalIntegerStringType(inverse: true)]),
			VerbosityLevel::value(),
			'non-decimal-int-string',
		];
	}

	#[DataProvider('dataDescribe')]
	public function testDescribe(IntersectionType $type, VerbosityLevel $verbosityLevel, string $expected): void
	{
		static::assertSame($expected, $type->describe($verbosityLevel));
	}

	public function testCallableArray(): void
	{
		$callableArray = new IntersectionType([new ArrayType(new MixedType(), new MixedType()), new CallableType()]);
		$this->assertSame('non-empty-list&callable(): mixed', $callableArray->describe(VerbosityLevel::precise()));
		$this->assertSame(TrinaryLogic::createYes()->describe(), $callableArray->isConstantArray()->describe());
		$this->assertSame(TrinaryLogic::createYes()->describe(), $callableArray->isList()->describe());
		$this->assertSame(TrinaryLogic::createYes()->describe(), $callableArray->hasOffsetValueType(new ConstantIntegerType(0))->describe());
		$this->assertSame(TrinaryLogic::createYes()->describe(), $callableArray->hasOffsetValueType(new ConstantIntegerType(1))->describe());
		$this->assertSame(TrinaryLogic::createNo()->describe(), $callableArray->hasOffsetValueType(new ConstantIntegerType(2))->describe());
		$this->assertSame(TrinaryLogic::createNo()->describe(), $callableArray->hasOffsetValueType(new ConstantIntegerType(-1))->describe());
		$this->assertSame(TrinaryLogic::createNo()->describe(), $callableArray->hasOffsetValueType(new ConstantStringType('foo'))->describe());
		$this->assertSame(TrinaryLogic::createMaybe()->describe(), $callableArray->hasOffsetValueType(new IntegerType())->describe());
		$this->assertSame(TrinaryLogic::createYes()->describe(), $callableArray->isIterableAtLeastOnce()->describe());
		$this->assertSame('2', $callableArray->getArraySize()->describe(VerbosityLevel::precise()));

		$constantArrays = $callableArray->getConstantArrays();
		$this->assertCount(1, $constantArrays);

		$this->assertSame('array{class-string|object, non-falsy-string}', $constantArrays[0]->describe(VerbosityLevel::precise()));
	}

	/**
	 * @return Iterator<string, array{IntersectionType}>
	 */
	public static function dataIntersectionWithTemplateMixed(): Iterator
	{
		$templateType = TemplateTypeFactory::create(
			TemplateTypeScope::createWithFunction('a'),
			'T',
			new MixedType(),
			TemplateTypeVariance::createInvariant(),
		);
		$objectType = new ObjectType(DateTimeImmutable::class);

		yield 'template first' => [new IntersectionType([$templateType, $objectType])];
		yield 'object first' => [new IntersectionType([$objectType, $templateType])];
	}

	#[DataProvider('dataIntersectionWithTemplateMixed')]
	public function testMethodOfIntersectionWithTemplateMixed(IntersectionType $type): void
	{
		$method = $type->getMethod('modify', new OutOfClassScope());
		$this->assertSame(DateTimeImmutable::class, $method->getDeclaringClass()->getName());

		$variant = $method->getOnlyVariant();
		$this->assertFalse($variant->isVariadic());
		$this->assertCount(1, $variant->getParameters());
		$this->assertSame('modifier', $variant->getParameters()[0]->getName());
	}

	#[DataProvider('dataIntersectionWithTemplateMixed')]
	public function testConstantOfIntersectionWithTemplateMixed(IntersectionType $type): void
	{
		$constant = $type->getConstant('ATOM');
		$this->assertSame(DateTimeInterface::class, $constant->getDeclaringClass()->getName());
	}

	/**
	 * @return Iterator<string, array{IntersectionType, list<string>}>
	 */
	public static function dataGetFiniteTypes(): Iterator
	{
		yield 'integers' => [
			new IntersectionType([
				new UnionType([new ConstantIntegerType(1), new ConstantIntegerType(2)]),
				new UnionType([new ConstantIntegerType(1), new ConstantIntegerType(2), new ConstantIntegerType(3)]),
			]),
			['1', '2'],
		];
		yield 'strings' => [
			new IntersectionType([
				new UnionType([new ConstantStringType('a'), new ConstantStringType('b'), new ConstantStringType('c')]),
				new UnionType([new ConstantStringType('c'), new ConstantStringType('a')]),
			]),
			["'a'", "'c'"],
		];
		yield 'floats' => [
			new IntersectionType([
				new UnionType([new ConstantFloatType(1.5), new ConstantFloatType(2.5)]),
				new UnionType([new ConstantFloatType(2.5), new ConstantFloatType(3.5)]),
			]),
			['2.5'],
		];
		yield 'mixed kinds' => [
			new IntersectionType([
				new UnionType([new ConstantIntegerType(1), new ConstantStringType('1'), new ConstantBooleanType(true), new NullType()]),
				new UnionType([new ConstantStringType('1'), new NullType(), new ConstantIntegerType(2)]),
			]),
			["'1'", 'null'],
		];
		yield 'disjoint' => [
			new IntersectionType([
				new UnionType([new ConstantIntegerType(1), new ConstantIntegerType(2)]),
				new UnionType([new ConstantIntegerType(3), new ConstantIntegerType(4)]),
			]),
			[],
		];
	}

	/**
	 * @param list<string> $expected
	 */
	#[DataProvider('dataGetFiniteTypes')]
	public function testGetFiniteTypes(IntersectionType $type, array $expected): void
	{
		$this->assertSame($expected, array_map(static fn (Type $finiteType): string => $finiteType->describe(VerbosityLevel::precise()), $type->getFiniteTypes()));
	}

	public function testSetOffsetValueTypeOnListWithOffsetAtIntMax(): void
	{
		$type = new IntersectionType([
			new ArrayType(new IntegerType(), new MixedType()),
			new AccessoryArrayListType(),
			new HasOffsetType(new ConstantIntegerType(PHP_INT_MAX)),
		]);

		$result = $type->setOffsetValueType(new ConstantIntegerType(3), new ConstantIntegerType(1));
		$this->assertTrue($result->isList()->yes());
		$this->assertSame('non-empty-list&hasOffset(9223372036854775807)&hasOffsetValue(3, 1)', $result->describe(VerbosityLevel::precise()));
	}

}