1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-11 08:49:52 +01:00
psalm/tests/TypeCombinationTest.php

830 lines
24 KiB
PHP

<?php
namespace Psalm\Tests;
use Psalm\Internal\Type\TypeCombiner;
use Psalm\Tests\Traits\ValidCodeAnalysisTestTrait;
use Psalm\Type;
use Psalm\Type\Atomic;
class TypeCombinationTest extends TestCase
{
use ValidCodeAnalysisTestTrait;
/**
* @dataProvider providerTestValidTypeCombination
*
* @param string $expected
* @param non-empty-list<string> $types
*
*/
public function testValidTypeCombination($expected, $types): void
{
$converted_types = [];
foreach ($types as $type) {
$converted_type = self::getAtomic($type);
$converted_type->from_docblock = true;
$converted_types[] = $converted_type;
}
$this->assertSame(
$expected,
TypeCombiner::combine($converted_types)->getId()
);
}
/**
* @return iterable<string,array{string,assertions?:array<string,string>,error_levels?:string[]}>
*/
public function providerValidCodeParse(): iterable
{
return [
'multipleValuedArray' => [
'<?php
class A {}
class B {}
$var = [];
$var[] = new A();
$var[] = new B();',
],
'preventLiteralAndClassString' => [
'<?php
/**
* @param "array"|class-string $type_name
*/
function foo(string $type_name) : bool {
return $type_name === "array";
}',
],
'NeverTwice' => [
'<?php
/** @return no-return */
function other() {
throw new Exception();
}
rand(0,1) ? die() : other();',
],
'ArrayAndTraversableNotIterable' => [
'<?php declare(strict_types=1);
/** @param mixed $identifier */
function isNullIdentifier($identifier): bool
{
if ($identifier instanceof \Traversable || is_array($identifier)) {
expectsTraversableOrArray($identifier);
}
return false;
}
/** @param Traversable|array<array-key, mixed> $_a */
function expectsTraversableOrArray($_a): void
{
}
',
],
];
}
/**
* @return array<string,array{string,non-empty-list<string>}>
*/
public function providerTestValidTypeCombination(): array
{
return [
'intOrString' => [
'int|string',
[
'int',
'string',
],
],
'mixedOrNull' => [
'mixed|null',
[
'mixed',
'null',
],
],
'mixedOrEmpty' => [
'mixed',
[
'empty',
'mixed',
],
],
'mixedOrObject' => [
'mixed|object',
[
'mixed',
'object',
],
],
'mixedOrEmptyArray' => [
'array<empty, empty>|mixed',
[
'mixed',
'array<empty, empty>',
],
],
'falseTrueToBool' => [
'bool',
[
'false',
'true',
],
],
'trueFalseToBool' => [
'bool',
[
'true',
'false',
],
],
'trueBoolToBool' => [
'bool',
[
'true',
'bool',
],
],
'boolTrueToBool' => [
'bool',
[
'bool',
'true',
],
],
'intOrTrueOrFalseToBool' => [
'bool|int',
[
'int',
'false',
'true',
],
],
'intOrBoolOrTrueToBool' => [
'bool|int',
[
'int',
'bool',
'true',
],
],
'intOrTrueOrBoolToBool' => [
'bool|int',
[
'int',
'true',
'bool',
],
],
'arrayOfIntOrString' => [
'array<array-key, int|string>',
[
'array<int>',
'array<string>',
],
],
'arrayOfIntOrAlsoString' => [
'array<array-key, int>|string',
[
'array<int>',
'string',
],
],
'emptyArrays' => [
'array<empty, empty>',
[
'array<empty,empty>',
'array<empty,empty>',
],
],
'arrayStringOrEmptyArray' => [
'array<array-key, string>',
[
'array<empty>',
'array<string>',
],
],
'arrayMixedOrString' => [
'array<array-key, mixed|string>',
[
'array<mixed>',
'array<string>',
],
],
'arrayMixedOrStringKeys' => [
'array<array-key, string>',
[
'array<int|string,string>',
'array<mixed,string>',
],
],
'arrayMixedOrEmpty' => [
'array<array-key, mixed>',
[
'array<empty>',
'array<mixed>',
],
],
'arrayBigCombination' => [
'array<array-key, float|int|string>',
[
'array<int|float>',
'array<string>',
],
],
'arrayTraversableToIterable' => [
'iterable<array-key|mixed, mixed>',
[
'array',
'Traversable',
],
],
'arrayIterableToIterable' => [
'iterable<mixed, mixed>',
[
'array',
'iterable',
],
],
'iterableArrayToIterable' => [
'iterable<mixed, mixed>',
[
'iterable',
'array',
],
],
'traversableIterableToIterable' => [
'iterable<mixed, mixed>',
[
'Traversable',
'iterable',
],
],
'iterableTraversableToIterable' => [
'iterable<mixed, mixed>',
[
'iterable',
'Traversable',
],
],
'arrayTraversableToIterableWithParams' => [
'iterable<int, bool|string>',
[
'array<int, string>',
'Traversable<int, bool>',
],
],
'arrayIterableToIterableWithParams' => [
'iterable<int, bool|string>',
[
'array<int, string>',
'iterable<int, bool>',
],
],
'iterableArrayToIterableWithParams' => [
'iterable<int, bool|string>',
[
'iterable<int, string>',
'array<int, bool>',
],
],
'traversableIterableToIterableWithParams' => [
'iterable<int, bool|string>',
[
'Traversable<int, string>',
'iterable<int, bool>',
],
],
'iterableTraversableToIterableWithParams' => [
'iterable<int, bool|string>',
[
'iterable<int, string>',
'Traversable<int, bool>',
],
],
'arrayObjectAndParamsWithEmptyArray' => [
'ArrayObject<int, string>|array<empty, empty>',
[
'ArrayObject<int, string>',
'array<empty, empty>',
],
],
'emptyArrayWithArrayObjectAndParams' => [
'ArrayObject<int, string>|array<empty, empty>',
[
'array<empty, empty>',
'ArrayObject<int, string>',
],
],
'falseDestruction' => [
'bool',
[
'false',
'bool',
],
],
'onlyFalse' => [
'false',
[
'false',
],
],
'onlyTrue' => [
'true',
[
'true',
],
],
'falseFalseDestruction' => [
'false',
[
'false',
'false',
],
],
'aAndAOfB' => [
'A|A<B>',
[
'A',
'A<B>',
],
],
'combineObjectType1' => [
'array{a?: int, b?: string}',
[
'array{a: int}',
'array{b: string}',
],
],
'combineObjectType2' => [
'array{a: int|string, b?: string}',
[
'array{a: int}',
'array{a: string,b: string}',
],
],
'combineObjectTypeWithIntKeyedArray' => [
'array<"a"|int, int|string>',
[
'array{a: int}',
'array<int, string>',
],
],
'combineNestedObjectTypeWithTKeyedArrayIntKeyedArray' => [
'array{a: array<"a"|int, int|string>}',
[
'array{a: array{a: int}}',
'array{a: array<int, string>}',
],
],
'combineIntKeyedObjectTypeWithNestedIntKeyedArray' => [
'array<int, array<"a"|int, int|string>>',
[
'array<int, array{a:int}>',
'array<int, array<int, string>>',
],
],
'combineNestedObjectTypeWithNestedIntKeyedArray' => [
'array<"a"|int, array<"a"|int, int|string>>',
[
'array{a: array{a: int}}',
'array<int, array<int, string>>',
],
],
'combinePossiblyUndefinedKeys' => [
'array{a: bool, b?: mixed, d?: mixed}',
[
'array{a: false, b: mixed}',
'array{a: true, d: mixed}',
'array{a: true, d: mixed}',
],
],
'combinePossiblyUndefinedKeysAndString' => [
'array{a: string, b?: int}|string',
[
'array{a: string, b?: int}',
'string',
],
],
'combineMixedArrayWithTKeyedArray' => [
'array<array-key, mixed>',
[
'array{a: int}',
'array',
],
],
'traversableAorB' => [
'Traversable<mixed, A|B>',
[
'Traversable<A>',
'Traversable<B>',
],
],
'iterableAorB' => [
'iterable<mixed, A|B>',
[
'iterable<A>',
'iterable<B>',
],
],
'FooAorB' => [
'Foo<A>|Foo<B>',
[
'Foo<A>',
'Foo<B>',
],
],
'traversableOfMixed' => [
'Traversable<mixed, mixed>',
[
'Traversable',
'Traversable<mixed, mixed>',
],
],
'traversableAndIterator' => [
'Traversable&Iterator',
[
'Traversable&Iterator',
'Traversable&Iterator',
],
],
'traversableOfMixedAndIterator' => [
'Traversable<mixed, mixed>&Iterator',
[
'Traversable<mixed, mixed>&Iterator',
'Traversable<mixed, mixed>&Iterator',
],
],
'objectLikePlusArrayEqualsArray' => [
'array<"a"|"b"|"c", 1|2|3>',
[
'array<"a"|"b"|"c", 1|2|3>',
'array{a: 1|2, b: 2|3, c: 1|3}',
],
],
'combineClosures' => [
'Closure(A):void|Closure(B):void',
[
'Closure(A):void',
'Closure(B):void',
],
],
'combineClassStringWithString' => [
'string',
[
'class-string',
'string',
],
],
'combineClassStringWithFalse' => [
'class-string|false',
[
'class-string',
'false',
],
],
'combineRefinedClassStringWithString' => [
'string',
[
'class-string<Exception>',
'string',
],
],
'combineRefinedClassStrings' => [
'class-string<Exception>|class-string<Iterator>',
[
'class-string<Exception>',
'class-string<Iterator>',
],
],
'combineClassStringsWithLiteral' => [
'class-string',
[
'class-string',
'Exception::class',
],
],
'combineClassStringWithNumericString' => [
'class-string|numeric-string',
[
'class-string',
'numeric-string',
],
],
'combineRefinedClassStringWithNumericString' => [
'class-string<Exception>|numeric-string',
[
'class-string<Exception>',
'numeric-string',
],
],
'combineClassStringWithTraitString' => [
'class-string|trait-string',
[
'class-string',
'trait-string',
],
],
'combineRefinedClassStringWithTraitString' => [
'class-string<Exception>|trait-string',
[
'class-string<Exception>',
'trait-string',
],
],
'combineCallableAndCallableString' => [
'callable',
[
'callable',
'callable-string',
],
],
'combineCallableStringAndCallable' => [
'callable',
[
'callable-string',
'callable'
],
],
'combineCallableAndCallableObject' => [
'callable',
[
'callable',
'callable-object',
],
],
'combineCallableObjectAndCallable' => [
'callable',
[
'callable-object',
'callable'
],
],
'combineCallableAndCallableArray' => [
'callable',
[
'callable',
'callable-array',
],
],
'combineCallableArrayAndCallable' => [
'callable',
[
'callable-array',
'callable'
],
],
'combineCallableArrayAndArray' => [
'array<array-key, mixed>',
[
'callable-array{class-string, string}',
'array',
],
],
'combineGenericArrayAndMixedArray' => [
'array<array-key, int|mixed>',
[
'array<string, int>',
'array<array-key, mixed>',
],
],
'combineTKeyedArrayAndArray' => [
'array<array-key, mixed>',
[
'array{hello: int}',
'array<array-key, mixed>',
],
],
'combineTKeyedArrayAndNestedArray' => [
'array<array-key, mixed>',
[
'array{hello: array{goodbye: int}}',
'array<array-key, mixed>',
],
],
'combineNumericStringWithLiteralString' => [
'numeric-string',
[
'numeric-string',
'"1"',
],
],
'combineLiteralStringWithNumericString' => [
'numeric-string',
[
'"1"',
'numeric-string',
],
],
'combineNonEmptyListWithTKeyedArrayList' => [
'array{0: null|string}<int, string>',
[
'non-empty-list<string>',
'array{null}'
],
],
'combineZeroAndPositiveInt' => [
'0|positive-int',
[
'0',
'positive-int',
],
],
'combinePositiveIntAndZero' => [
'0|positive-int',
[
'positive-int',
'0',
],
],
'combinePositiveIntAndMinusOne' => [
'int',
[
'positive-int',
'-1',
],
],
'combinePositiveIntZeroAndMinusOne' => [
'int',
[
'0',
'positive-int',
'-1',
],
],
'combineMinusOneAndPositiveInt' => [
'int',
[
'-1',
'positive-int',
],
],
'combineZeroMinusOneAndPositiveInt' => [
'int',
[
'0',
'-1',
'positive-int',
],
],
'combineZeroOneAndPositiveInt' => [
'0|positive-int',
[
'0',
'1',
'positive-int',
],
],
'combinePositiveIntOneAndZero' => [
'0|positive-int',
[
'positive-int',
'1',
'0',
],
],
'combinePositiveInts' => [
'positive-int',
[
'positive-int',
'positive-int',
],
],
'combineNonEmptyArrayAndKeyedArray' => [
'array<int, int>',
[
'non-empty-array<int, int>',
'array{0?:int}',
]
],
'combineNonEmptyStringAndLiteral' => [
'non-empty-string',
[
'non-empty-string',
'"foo"',
]
],
'combineLiteralAndNonEmptyString' => [
'non-empty-string',
[
'"foo"',
'non-empty-string'
]
],
'combineNonFalsyNonEmptyString' => [
'non-empty-string',
[
'non-falsy-string',
'non-empty-string'
]
],
'combineNonEmptyNonFalsyString' => [
'non-empty-string',
[
'non-empty-string',
'non-falsy-string'
]
],
'combineNonEmptyStringAndNumericString' => [
'non-empty-string',
[
'non-empty-string',
'numeric-string'
]
],
'combineNumericStringAndNonEmptyString' => [
'non-empty-string',
[
'numeric-string',
'non-empty-string'
]
],
'combineNonEmptyLowercaseAndNonFalsyString' => [
'non-empty-string',
[
'non-falsy-string',
'non-empty-lowercase-string',
]
],
'combineNonEmptyAndEmptyScalar' => [
'scalar',
[
'non-empty-scalar',
'empty-scalar',
]
],
'combineLiteralStringAndNonspecificLiteral' => [
'literal-string',
[
'literal-string',
'"foo"',
]
],
'combineNonspecificLiteralAndLiteralString' => [
'literal-string',
[
'"foo"',
'literal-string',
]
],
'combineLiteralIntAndNonspecificLiteral' => [
'literal-int',
[
'literal-int',
'5',
]
],
'combineNonspecificLiteralAndLiteralInt' => [
'literal-int',
[
'5',
'literal-int',
]
],
'combineNonspecificLiteralAndPositiveInt' => [
'int',
[
'positive-int',
'literal-int',
]
],
'combinePositiveAndLiteralInt' => [
'int',
[
'literal-int',
'positive-int',
]
],
'combineNonEmptyStringAndNonEmptyNonSpecificLiteralString' => [
'non-empty-string',
[
'non-empty-literal-string',
'non-empty-string',
],
],
'combineNonEmptyNonSpecificLiteralStringAndNonEmptyString' => [
'non-empty-string',
[
'non-empty-string',
'non-empty-literal-string',
],
],
];
}
/**
* @param string $string
*
*/
private static function getAtomic($string): Atomic
{
return Type::parseString($string)->getSingleAtomic();
}
}