1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-12 09:19:40 +01:00
psalm/src/Psalm/Type.php

915 lines
27 KiB
PHP
Raw Normal View History

2016-06-14 07:23:57 +02:00
<?php
2016-07-26 00:37:44 +02:00
namespace Psalm;
2016-06-14 07:23:57 +02:00
2016-11-21 05:31:10 +01:00
use Psalm\Exception\TypeParseTreeException;
2016-07-26 00:37:44 +02:00
use Psalm\Type\Atomic;
use Psalm\Type\Atomic\ObjectLike;
use Psalm\Type\Atomic\TArray;
use Psalm\Type\Atomic\TBool;
use Psalm\Type\Atomic\TClassString;
use Psalm\Type\Atomic\TEmpty;
use Psalm\Type\Atomic\TFalse;
use Psalm\Type\Atomic\TFloat;
use Psalm\Type\Atomic\TGenericObject;
use Psalm\Type\Atomic\TInt;
use Psalm\Type\Atomic\TMixed;
use Psalm\Type\Atomic\TNamedObject;
use Psalm\Type\Atomic\TNull;
use Psalm\Type\Atomic\TNumeric;
use Psalm\Type\Atomic\TObject;
use Psalm\Type\Atomic\TResource;
use Psalm\Type\Atomic\TString;
use Psalm\Type\Atomic\TTrue;
use Psalm\Type\Atomic\TVoid;
2016-07-26 00:37:44 +02:00
use Psalm\Type\ParseTree;
2017-06-29 17:18:02 +02:00
use Psalm\Type\TypeCombination;
2016-11-02 07:29:00 +01:00
use Psalm\Type\Union;
2016-06-14 07:23:57 +02:00
abstract class Type
{
/**
2018-02-22 00:59:31 +01:00
* @var array<string, array<int, string>>
*/
private static $memoized_tokens = [];
2016-06-14 07:23:57 +02:00
/**
* Parses a string type representation
2016-11-02 07:29:00 +01:00
*
* @param string $type_string
* @param bool $php_compatible
2017-05-27 02:16:18 +02:00
*
2016-06-28 20:28:45 +02:00
* @return Union
2016-06-14 07:23:57 +02:00
*/
public static function parseString($type_string, $php_compatible = false)
2016-06-14 07:23:57 +02:00
{
2016-11-21 05:31:10 +01:00
// remove all unacceptable characters
$type_string = preg_replace('/[^A-Za-z0-9\-_\\\\&|\? \<\>\{\}:,\]\[\(\)\$]/', '', trim($type_string));
2016-11-21 05:31:10 +01:00
2016-06-27 04:02:23 +02:00
if (strpos($type_string, '[') !== false) {
$type_string = self::convertSquareBrackets($type_string);
2016-06-27 04:02:23 +02:00
}
2017-11-20 06:37:45 +01:00
$type_string = preg_replace('/\?(?=[a-zA-Z])/', 'null|', $type_string);
$type_tokens = self::tokenize($type_string);
2016-06-14 07:23:57 +02:00
if (count($type_tokens) === 1) {
$type_tokens[0] = self::fixScalarTerms($type_tokens[0], $php_compatible);
2016-06-24 00:45:46 +02:00
return new Union([Atomic::create($type_tokens[0], $php_compatible)]);
2016-06-14 07:23:57 +02:00
}
2016-11-21 05:31:10 +01:00
try {
$parse_tree = ParseTree::createFromTokens($type_tokens);
$parsed_type = self::getTypeFromTree($parse_tree, $php_compatible);
} catch (TypeParseTreeException $e) {
2016-11-21 05:31:10 +01:00
throw $e;
}
2016-06-14 07:23:57 +02:00
2016-06-28 20:28:45 +02:00
if (!($parsed_type instanceof Union)) {
2016-06-15 01:22:29 +02:00
$parsed_type = new Union([$parsed_type]);
}
return $parsed_type;
2016-06-14 07:23:57 +02:00
}
2016-10-15 06:12:57 +02:00
/**
* @param string $type_string
* @param bool $php_compatible
2017-05-27 02:16:18 +02:00
*
2016-10-15 06:12:57 +02:00
* @return string
*/
private static function fixScalarTerms($type_string, $php_compatible = false)
{
$type_string_lc = strtolower($type_string);
switch ($type_string_lc) {
case 'int':
case 'void':
case 'float':
case 'string':
case 'bool':
case 'callable':
case 'iterable':
case 'array':
case 'object':
case 'numeric':
case 'true':
case 'false':
case 'null':
case 'mixed':
case 'resource':
return $type_string_lc;
}
switch ($type_string) {
case 'boolean':
return $php_compatible ? $type_string : 'bool';
case 'integer':
return $php_compatible ? $type_string : 'int';
case 'double':
case 'real':
return $php_compatible ? $type_string : 'float';
2016-08-14 18:07:19 +02:00
}
return $type_string;
}
2016-11-02 07:29:00 +01:00
/**
* @param ParseTree $parse_tree
* @param bool $php_compatible
2017-05-27 02:16:18 +02:00
*
* @return Atomic|TArray|TGenericObject|ObjectLike|Union
2016-11-02 07:29:00 +01:00
*/
private static function getTypeFromTree(ParseTree $parse_tree, $php_compatible)
2016-06-14 07:23:57 +02:00
{
2018-03-21 01:19:26 +01:00
if ($parse_tree instanceof ParseTree\GenericTree) {
$generic_type = $parse_tree->value;
2016-06-14 07:23:57 +02:00
$generic_params = array_map(
2016-12-07 20:13:39 +01:00
/**
* @return Union
*/
2016-06-14 07:23:57 +02:00
function (ParseTree $child_tree) {
$tree_type = self::getTypeFromTree($child_tree, false);
2017-05-25 04:07:49 +02:00
return $tree_type instanceof Union ? $tree_type : new Union([$tree_type]);
2016-06-14 07:23:57 +02:00
},
$parse_tree->children
);
2018-03-21 01:19:26 +01:00
$generic_type_value = self::fixScalarTerms($generic_type, false);
2016-09-09 22:21:49 +02:00
2016-11-02 07:29:00 +01:00
if (($generic_type_value === 'array' || $generic_type_value === 'Generator') &&
count($generic_params) === 1
) {
array_unshift($generic_params, new Union([new TMixed]));
2016-09-09 22:21:49 +02:00
}
2016-06-14 07:23:57 +02:00
if (!$generic_params) {
throw new \InvalidArgumentException('No generic params provided for type');
}
2016-09-22 04:15:46 +02:00
if ($generic_type_value === 'array') {
return new TArray($generic_params);
2016-09-22 04:15:46 +02:00
}
return new TGenericObject($generic_type_value, $generic_params);
2016-06-14 07:23:57 +02:00
}
2018-03-21 01:19:26 +01:00
if ($parse_tree instanceof ParseTree\UnionTree) {
2016-06-14 07:23:57 +02:00
$union_types = array_map(
2016-12-07 20:13:39 +01:00
/**
* @return Atomic
*/
2016-06-14 07:23:57 +02:00
function (ParseTree $child_tree) {
$atomic_type = self::getTypeFromTree($child_tree, false);
2016-12-07 20:13:39 +01:00
if (!$atomic_type instanceof Atomic) {
throw new \UnexpectedValueException(
'Was expecting an atomic type, got ' . get_class($atomic_type)
);
}
return $atomic_type;
2016-06-14 07:23:57 +02:00
},
$parse_tree->children
);
2016-11-20 08:52:34 +01:00
return self::combineTypes($union_types);
2016-06-14 07:23:57 +02:00
}
2018-03-21 01:19:26 +01:00
if ($parse_tree instanceof ParseTree\IntersectionTree) {
$intersection_types = array_map(
/**
* @return Atomic
*/
function (ParseTree $child_tree) {
$atomic_type = self::getTypeFromTree($child_tree, false);
if (!$atomic_type instanceof Atomic) {
throw new \UnexpectedValueException(
'Was expecting an atomic type, got ' . get_class($atomic_type)
);
}
return $atomic_type;
},
$parse_tree->children
);
foreach ($intersection_types as $intersection_type) {
if (!$intersection_type instanceof TNamedObject) {
throw new TypeParseTreeException('Intersection types must all be objects');
}
}
/** @var TNamedObject[] $intersection_types */
$first_type = array_shift($intersection_types);
$first_type->extra_types = $intersection_types;
return new Type\Union([$first_type]);
}
2018-03-21 01:19:26 +01:00
if ($parse_tree instanceof ParseTree\ObjectLikeTree) {
$properties = [];
2018-03-21 01:19:26 +01:00
$type = $parse_tree->value;
foreach ($parse_tree->children as $i => $property_branch) {
2018-03-21 01:19:26 +01:00
if (!$property_branch instanceof ParseTree\ObjectLikePropertyTree) {
$property_type = self::getTypeFromTree($property_branch, false);
$property_maybe_undefined = false;
$property_key = (string)$i;
2018-03-21 01:19:26 +01:00
} elseif (count($property_branch->children) === 1) {
$property_type = self::getTypeFromTree($property_branch->children[0], false);
$property_maybe_undefined = $property_branch->possibly_undefined;
2018-03-21 01:19:26 +01:00
$property_key = $property_branch->value;
} else {
2018-03-21 01:19:26 +01:00
throw new \InvalidArgumentException(
'Unexpected number of property parts (' . count($property_branch->children) . ')'
);
}
2016-10-03 00:59:16 +02:00
if (!$property_type instanceof Union) {
$property_type = new Union([$property_type]);
}
if ($property_maybe_undefined) {
$property_type->possibly_undefined = true;
}
$properties[$property_key] = $property_type;
}
2018-03-21 01:19:26 +01:00
if ($type !== 'array') {
throw new \InvalidArgumentException('Object-like type must be array');
2016-10-30 17:46:18 +01:00
}
if (!$properties) {
throw new \InvalidArgumentException('No properties supplied for ObjectLike');
}
return new ObjectLike($properties);
}
2018-03-21 01:19:26 +01:00
if (!$parse_tree instanceof ParseTree\Value) {
throw new \InvalidArgumentException('Unrecognised parse tree type');
}
$atomic_type = self::fixScalarTerms($parse_tree->value, $php_compatible);
2016-09-09 22:21:49 +02:00
return Atomic::create($atomic_type, $php_compatible);
}
/**
2016-10-30 17:46:18 +01:00
* @param string $return_type
* @param bool $ignore_space
2017-05-27 02:16:18 +02:00
*
2016-10-03 17:38:59 +02:00
* @return array<int,string>
*/
public static function tokenize($return_type, $ignore_space = true)
{
$return_type_tokens = [''];
$was_char = false;
if ($ignore_space) {
$return_type = str_replace(' ', '', $return_type);
}
if (isset(self::$memoized_tokens[$return_type])) {
return self::$memoized_tokens[$return_type];
}
2018-01-21 03:22:33 +01:00
// index of last type token
$rtc = 0;
foreach (str_split($return_type) as $char) {
if ($was_char) {
2018-01-21 03:22:33 +01:00
$return_type_tokens[++$rtc] = '';
}
2016-11-02 07:29:00 +01:00
if ($char === '<' ||
$char === '>' ||
$char === '|' ||
$char === '?' ||
$char === ',' ||
$char === '{' ||
$char === '}' ||
$char === '[' ||
$char === ']' ||
2018-03-21 01:19:26 +01:00
$char === '(' ||
$char === ')' ||
$char === ' ' ||
$char === '&' ||
2016-11-02 07:29:00 +01:00
$char === ':'
) {
2018-01-21 03:22:33 +01:00
if ($return_type_tokens[$rtc] === '') {
$return_type_tokens[$rtc] = $char;
2016-11-02 07:29:00 +01:00
} else {
2018-01-21 03:22:33 +01:00
$return_type_tokens[++$rtc] = $char;
}
$was_char = true;
2016-11-02 07:29:00 +01:00
} else {
2018-01-21 03:22:33 +01:00
$return_type_tokens[$rtc] .= $char;
$was_char = false;
}
}
self::$memoized_tokens[$return_type] = $return_type_tokens;
return $return_type_tokens;
}
/**
* @param string $return_type
* @param Aliases $aliases
* @param array<string, string>|null $template_types
*
* @return string
*/
public static function fixUpLocalType(
$return_type,
Aliases $aliases,
array $template_types = null
) {
if (strpos($return_type, '[') !== false) {
$return_type = self::convertSquareBrackets($return_type);
}
$return_type_tokens = self::tokenize($return_type);
foreach ($return_type_tokens as $i => &$return_type_token) {
if (in_array($return_type_token, ['<', '>', '|', '?', ',', '{', '}', ':'], true)) {
continue;
}
if (isset($return_type_tokens[$i + 1]) && $return_type_tokens[$i + 1] === ':') {
continue;
}
$return_type_token = self::fixScalarTerms($return_type_token);
if ($return_type_token[0] === strtoupper($return_type_token[0]) &&
!isset($template_types[$return_type_token])
) {
if ($return_type_token[0] === '$') {
if ($return_type === '$this') {
$return_type_token = 'static';
}
continue;
}
$return_type_token = self::getFQCLNFromString(
$return_type_token,
$aliases
);
}
}
return implode('', $return_type_tokens);
}
/**
* @param string $class
* @param Aliases $aliases
*
* @return string
*/
public static function getFQCLNFromString($class, Aliases $aliases)
{
if (empty($class)) {
throw new \InvalidArgumentException('$class cannot be empty');
}
if ($class[0] === '\\') {
return substr($class, 1);
}
$imported_namespaces = $aliases->uses;
if (strpos($class, '\\') !== false) {
$class_parts = explode('\\', $class);
$first_namespace = array_shift($class_parts);
if (isset($imported_namespaces[strtolower($first_namespace)])) {
return $imported_namespaces[strtolower($first_namespace)] . '\\' . implode('\\', $class_parts);
}
} elseif (isset($imported_namespaces[strtolower($class)])) {
return $imported_namespaces[strtolower($class)];
}
$namespace = $aliases->namespace;
return ($namespace ? $namespace . '\\' : '') . $class;
}
2016-10-30 17:46:18 +01:00
/**
* @param string $type
2017-05-27 02:16:18 +02:00
*
2016-10-30 17:46:18 +01:00
* @return string
*/
public static function convertSquareBrackets($type)
{
$class_chars = '[a-zA-Z0-9\<\>\\\\_]+';
2017-05-25 04:07:49 +02:00
return preg_replace_callback(
2016-11-20 08:52:34 +01:00
'/(' . $class_chars . '|' . '\((' . $class_chars . '(\|' . $class_chars . ')*' . ')\))((\[\])+)/',
2016-12-07 20:13:39 +01:00
/**
* @return string
*/
function (array $matches) {
2016-10-30 17:46:18 +01:00
$inner_type = str_replace(['(', ')'], '', (string)$matches[1]);
2016-11-20 08:52:34 +01:00
$dimensionality = strlen((string)$matches[4]) / 2;
2017-05-27 02:05:57 +02:00
for ($i = 0; $i < $dimensionality; ++$i) {
2016-11-20 08:52:34 +01:00
$inner_type = 'array<mixed,' . $inner_type . '>';
}
return $inner_type;
},
$type
);
2016-06-14 07:23:57 +02:00
}
2016-06-15 01:22:29 +02:00
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getInt()
2016-06-15 01:22:29 +02:00
{
$type = new TInt;
2016-06-15 01:22:29 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-15 01:22:29 +02:00
}
/**
* @return Type\Union
*/
public static function getNumeric()
{
$type = new TNumeric;
return new Union([$type]);
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getString()
2016-06-15 01:22:29 +02:00
{
$type = new TString;
2016-06-15 01:22:29 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-15 01:22:29 +02:00
}
/**
* @return Type\Union
*/
public static function getClassString()
{
$type = new TClassString;
return new Union([$type]);
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getNull()
2016-06-16 02:16:40 +02:00
{
$type = new TNull;
2016-06-16 02:16:40 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-16 02:16:40 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getMixed()
2016-06-15 01:22:29 +02:00
{
$type = new TMixed;
2016-06-15 01:22:29 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-15 01:22:29 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getBool()
2016-06-15 01:22:29 +02:00
{
$type = new TBool;
2016-06-15 01:22:29 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-15 01:22:29 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getFloat()
2016-06-15 01:22:29 +02:00
{
$type = new TFloat;
2016-06-15 01:22:29 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-15 01:22:29 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getObject()
2016-06-15 01:22:29 +02:00
{
$type = new TObject;
2016-06-15 01:22:29 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-15 01:22:29 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-10-21 00:05:28 +02:00
public static function getClosure()
{
$type = new TNamedObject('Closure');
2016-10-21 00:05:28 +02:00
return new Union([$type]);
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getArray()
2016-06-15 01:22:29 +02:00
{
$type = new TArray(
2016-09-09 22:21:49 +02:00
[
new Type\Union([new TMixed]),
2017-05-27 02:05:57 +02:00
new Type\Union([new TMixed]),
2016-09-09 22:21:49 +02:00
]
);
2016-06-15 01:22:29 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-15 01:22:29 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-12 06:02:26 +02:00
public static function getEmptyArray()
{
return new Type\Union([
new TArray(
2016-09-12 06:02:26 +02:00
[
new Type\Union([new TEmpty]),
2017-05-27 02:05:57 +02:00
new Type\Union([new TEmpty]),
2016-09-12 06:02:26 +02:00
]
2017-05-27 02:05:57 +02:00
),
2016-09-12 06:02:26 +02:00
]);
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getVoid()
2016-06-16 02:16:40 +02:00
{
$type = new TVoid;
2016-06-16 02:16:40 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-16 02:16:40 +02:00
}
2016-11-02 07:29:00 +01:00
/**
* @return Type\Union
*/
2016-09-09 22:21:49 +02:00
public static function getFalse()
2016-06-16 02:16:40 +02:00
{
$type = new TFalse;
2016-06-16 02:16:40 +02:00
2016-09-09 22:21:49 +02:00
return new Union([$type]);
2016-06-16 02:16:40 +02:00
}
/**
* @return Type\Union
*/
public static function getTrue()
{
$type = new TTrue;
return new Union([$type]);
}
/**
* @return Type\Union
*/
public static function getResource()
{
return new Union([new TResource]);
}
2016-06-16 02:16:40 +02:00
/**
* Combines two union types into one
2016-11-02 07:29:00 +01:00
*
2016-06-16 02:16:40 +02:00
* @param Union $type_1
* @param Union $type_2
2017-05-27 02:16:18 +02:00
*
2016-06-16 02:16:40 +02:00
* @return Union
*/
public static function combineUnionTypes(Union $type_1, Union $type_2)
2016-06-15 01:22:29 +02:00
{
if ($type_1->isMixed() || $type_2->isMixed()) {
return Type::getMixed();
}
2017-03-13 23:06:56 +01:00
$both_failed_reconciliation = false;
if ($type_1->failed_reconciliation) {
if ($type_2->failed_reconciliation) {
$both_failed_reconciliation = true;
} else {
return $type_2;
}
} elseif ($type_2->failed_reconciliation) {
return $type_1;
}
$combined_type = self::combineTypes(
array_merge(
array_values($type_1->getTypes()),
array_values($type_2->getTypes())
)
);
if (!$type_1->initialized || !$type_2->initialized) {
$combined_type->initialized = false;
}
if ($type_1->from_docblock || $type_2->from_docblock) {
$combined_type->from_docblock = true;
}
if ($type_1->ignore_nullable_issues || $type_2->ignore_nullable_issues) {
$combined_type->ignore_nullable_issues = true;
}
if ($type_1->ignore_falsable_issues || $type_2->ignore_falsable_issues) {
$combined_type->ignore_falsable_issues = true;
}
2017-03-13 23:06:56 +01:00
if ($both_failed_reconciliation) {
$combined_type->failed_reconciliation = true;
}
if ($type_1->possibly_undefined && $type_2->possibly_undefined) {
$combined_type->possibly_undefined = true;
}
return $combined_type;
2016-06-16 02:16:40 +02:00
}
2016-06-15 01:22:29 +02:00
2016-06-16 02:16:40 +02:00
/**
* Combines types together
2016-11-02 07:29:00 +01:00
* - so `int + string = int|string`
* - so `array<int> + array<string> = array<int|string>`
* - and `array<int> + string = array<int>|string`
* - and `array<empty> + array<empty> = array<empty>`
* - and `array<string> + array<empty> = array<string>`
* - and `array + array<string> = array<mixed>`
2016-06-16 02:16:40 +02:00
*
* @param array<Atomic> $types
2017-05-27 02:16:18 +02:00
*
2016-06-16 02:16:40 +02:00
* @return Union
2016-12-25 02:08:58 +01:00
* @psalm-suppress TypeCoercion
2016-06-16 02:16:40 +02:00
*/
public static function combineTypes(array $types)
2016-06-16 02:16:40 +02:00
{
2017-05-27 02:05:57 +02:00
if (in_array(null, $types, true)) {
2016-06-16 02:16:40 +02:00
return Type::getMixed();
}
if (count($types) === 1) {
2018-01-07 22:11:51 +01:00
$union_type = new Union([$types[0]]);
if ($types[0]->from_docblock) {
$union_type->from_docblock = true;
}
return $union_type;
2016-06-16 02:16:40 +02:00
}
if (!$types) {
throw new \InvalidArgumentException('You must pass at least one type to combineTypes');
}
2017-06-29 17:18:02 +02:00
$combination = new TypeCombination();
2016-06-16 02:16:40 +02:00
2018-01-07 22:11:51 +01:00
$from_docblock = false;
2016-06-16 02:16:40 +02:00
foreach ($types as $type) {
2018-01-07 22:11:51 +01:00
$from_docblock = $from_docblock || $type->from_docblock;
2017-06-29 17:18:02 +02:00
$result = self::scrapeTypeProperties($type, $combination);
2016-11-05 03:11:46 +01:00
if ($result) {
2018-01-07 22:11:51 +01:00
if ($from_docblock) {
$result->from_docblock = true;
}
2016-11-05 03:11:46 +01:00
return $result;
2016-09-09 22:21:49 +02:00
}
2016-06-16 02:16:40 +02:00
}
if (count($combination->value_types) === 1
&& !count($combination->objectlike_entries)
&& !count($combination->type_params)
) {
if (isset($combination->value_types['false'])) {
2018-01-07 22:11:51 +01:00
$union_type = Type::getFalse();
if ($from_docblock) {
$union_type->from_docblock = true;
}
return $union_type;
}
if (isset($combination->value_types['true'])) {
2018-01-07 22:11:51 +01:00
$union_type = Type::getTrue();
if ($from_docblock) {
$union_type->from_docblock = true;
}
return $union_type;
2016-06-16 07:19:52 +02:00
}
2017-06-29 17:18:02 +02:00
} elseif (isset($combination->value_types['void'])) {
unset($combination->value_types['void']);
2016-11-13 05:59:31 +01:00
2018-01-23 18:03:18 +01:00
// if we're merging with another type, we cannot represent it in PHP
$from_docblock = true;
2017-06-29 17:18:02 +02:00
if (!isset($combination->value_types['null'])) {
$combination->value_types['null'] = new TNull();
2016-11-13 05:59:31 +01:00
}
2016-06-16 07:19:52 +02:00
}
2017-12-09 21:51:38 +01:00
if (isset($combination->value_types['true']) && isset($combination->value_types['false'])) {
unset($combination->value_types['true'], $combination->value_types['false']);
$combination->value_types['bool'] = new TBool();
}
2016-06-16 02:16:40 +02:00
$new_types = [];
if (count($combination->objectlike_entries) &&
(!isset($combination->type_params['array'])
|| $combination->type_params['array'][1]->isEmpty())
) {
$new_types[] = new ObjectLike($combination->objectlike_entries);
2016-09-10 00:36:35 +02:00
// if we're merging an empty array with an object-like, clobber empty array
unset($combination->type_params['array']);
}
2016-06-15 01:22:29 +02:00
foreach ($combination->type_params as $generic_type => $generic_type_params) {
if ($generic_type === 'array') {
if ($combination->objectlike_entries) {
$objectlike_generic_type = null;
$objectlike_keys = [];
foreach ($combination->objectlike_entries as $property_name => $property_type) {
if ($objectlike_generic_type) {
$objectlike_generic_type = Type::combineUnionTypes(
$property_type,
$objectlike_generic_type
);
} else {
$objectlike_generic_type = clone $property_type;
}
if (is_int($property_name)) {
if (!isset($objectlike_keys['int'])) {
$objectlike_keys['int'] = new TInt;
}
} else {
if (!isset($objectlike_keys['string'])) {
$objectlike_keys['string'] = new TString;
}
}
}
if (!$objectlike_generic_type) {
throw new \InvalidArgumentException('Cannot be null');
}
$objectlike_generic_type->possibly_undefined = false;
$objectlike_key_type = new Type\Union(array_values($objectlike_keys));
$generic_type_params[0] = Type::combineUnionTypes(
$generic_type_params[0],
$objectlike_key_type
);
$generic_type_params[1] = Type::combineUnionTypes(
$generic_type_params[1],
$objectlike_generic_type
);
}
$new_types[] = new TArray($generic_type_params);
} elseif (!isset($combination->value_types[$generic_type])) {
$new_types[] = new TGenericObject($generic_type, $generic_type_params);
}
2016-06-15 01:22:29 +02:00
}
foreach ($combination->value_types as $type) {
if (!($type instanceof TEmpty)
|| (count($combination->value_types) === 1
&& !count($new_types))
) {
$new_types[] = $type;
}
}
2016-06-16 02:16:40 +02:00
$new_types = array_values($new_types);
2018-01-07 22:11:51 +01:00
$union_type = new Union($new_types);
if ($from_docblock) {
$union_type->from_docblock = true;
}
return $union_type;
2016-06-15 01:22:29 +02:00
}
2016-11-05 03:11:46 +01:00
/**
2017-06-29 17:18:02 +02:00
* @param Atomic $type
* @param TypeCombination $combination
2017-05-27 02:16:18 +02:00
*
2016-11-05 03:11:46 +01:00
* @return null|Union
*/
2017-06-29 17:18:02 +02:00
public static function scrapeTypeProperties(Atomic $type, TypeCombination $combination)
2016-11-05 03:11:46 +01:00
{
if ($type instanceof TMixed) {
2016-11-05 03:11:46 +01:00
return Type::getMixed();
}
// deal with false|bool => bool
if (($type instanceof TFalse || $type instanceof TTrue) && isset($combination->value_types['bool'])) {
2016-11-05 03:11:46 +01:00
return null;
}
2017-12-09 21:51:38 +01:00
if (get_class($type) === 'Psalm\\Type\\Atomic\\TBool' && isset($combination->value_types['false'])) {
2017-06-29 17:18:02 +02:00
unset($combination->value_types['false']);
2016-11-05 03:11:46 +01:00
}
2017-12-09 21:51:38 +01:00
if (get_class($type) === 'Psalm\\Type\\Atomic\\TBool' && isset($combination->value_types['true'])) {
unset($combination->value_types['true']);
}
$type_key = $type->getKey();
if ($type instanceof TArray || $type instanceof TGenericObject) {
foreach ($type->type_params as $i => $type_param) {
if (isset($combination->type_params[$type_key][$i])) {
$combination->type_params[$type_key][$i] = Type::combineUnionTypes(
$combination->type_params[$type_key][$i],
$type_param
);
} else {
$combination->type_params[$type_key][$i] = $type_param;
}
2016-11-05 03:11:46 +01:00
}
} elseif ($type instanceof ObjectLike) {
$existing_objectlike_entries = (bool) $combination->objectlike_entries;
$possibly_undefined_entries = $combination->objectlike_entries;
2016-11-05 03:11:46 +01:00
foreach ($type->properties as $candidate_property_name => $candidate_property_type) {
$value_type = isset($combination->objectlike_entries[$candidate_property_name])
? $combination->objectlike_entries[$candidate_property_name]
: null;
if (!$value_type) {
$combination->objectlike_entries[$candidate_property_name] = clone $candidate_property_type;
// it's possibly undefined if there are existing objectlike entries
$combination->objectlike_entries[$candidate_property_name]->possibly_undefined
= $existing_objectlike_entries;
2016-11-05 03:11:46 +01:00
} else {
$combination->objectlike_entries[$candidate_property_name] = Type::combineUnionTypes(
$value_type,
2016-11-05 03:11:46 +01:00
$candidate_property_type
);
}
unset($possibly_undefined_entries[$candidate_property_name]);
}
foreach ($possibly_undefined_entries as $type) {
$type->possibly_undefined = true;
2016-11-05 03:11:46 +01:00
}
} else {
$combination->value_types[$type_key] = $type;
2016-11-05 03:11:46 +01:00
}
}
2016-06-14 07:23:57 +02:00
}