1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-04 18:48:03 +01:00
psalm/tests/IssetTest.php

563 lines
19 KiB
PHP
Raw Normal View History

<?php
namespace Psalm\Tests;
class IssetTest extends TestCase
{
2018-11-06 03:57:36 +01:00
use Traits\ValidCodeAnalysisTestTrait;
use Traits\InvalidCodeAnalysisTestTrait;
/**
2019-03-01 21:55:20 +01:00
* @return iterable<string,array{string,assertions?:array<string,string>,error_levels?:string[]}>
*/
2018-11-06 03:57:36 +01:00
public function providerValidCodeParse()
{
return [
'issetWithSimpleAssignment' => [
'<?php
$array = [];
if (isset($array[$a = 5])) {
print "hello";
}
print $a;',
'assertions' => [],
'error_levels' => ['EmptyArrayAccess'],
],
'issetWithMultipleAssignments' => [
'<?php
if (rand(0, 4) > 2) {
$arr = [5 => [3 => "hello"]];
}
if (isset($arr[$a = 5][$b = 3])) {
}
echo $a;
echo $b;',
'assertions' => [],
'error_levels' => ['MixedArrayAccess'],
],
'isset' => [
'<?php
$a = isset($b) ? $b : null;',
'assertions' => [
'$a' => 'mixed|null',
],
2017-05-27 02:05:57 +02:00
'error_levels' => ['MixedAssignment'],
],
'nullCoalesce' => [
'<?php
$a = $b ?? null;',
'assertions' => [
'$a' => 'mixed|null',
],
2017-05-27 02:05:57 +02:00
'error_levels' => ['MixedAssignment'],
],
'nullCoalesceWithGoodVariable' => [
'<?php
$b = rand(0, 10) > 5 ? "hello" : null;
$a = $b ?? null;',
'assertions' => [
'$a' => 'string|null',
2017-05-27 02:05:57 +02:00
],
],
'issetKeyedOffset' => [
'<?php
function getArray() : array {
return [];
}
$foo = getArray();
if (!isset($foo["a"])) {
$foo["a"] = "hello";
}',
'assertions' => [
'$foo[\'a\']' => 'string|mixed',
],
'error_levels' => [],
],
'issetKeyedOffsetORFalse' => [
'<?php
/** @return void */
function takesString(string $str) {}
2017-06-29 16:22:49 +02:00
$bar = rand(0, 1) ? ["foo" => "bar"] : false;
2017-06-29 16:22:49 +02:00
if (isset($bar["foo"])) {
takesString($bar["foo"]);
}',
'assertions' => [],
'error_levels' => ['PossiblyInvalidArrayAccess'],
],
'nullCoalesceKeyedOffset' => [
'<?php
function getArray() : array {
return [];
}
$foo = getArray();
$foo["a"] = $foo["a"] ?? "hello";',
'assertions' => [
'$foo[\'a\']' => 'string|mixed',
],
'error_levels' => ['MixedAssignment'],
2017-05-27 02:05:57 +02:00
],
'noRedundantConditionOnMixed' => [
'<?php
2018-01-11 21:50:45 +01:00
function testarray(array $data): void {
foreach ($data as $item) {
if (isset($item["a"]) && isset($item["b"]["c"])) {
echo "Found\n";
}
}
}',
'assertions' => [],
'error_levels' => ['MixedAssignment', 'MixedArrayAccess'],
],
'testUnset' => [
'<?php
$foo = ["a", "b", "c"];
foreach ($foo as $bar) {}
unset($foo, $bar);
2018-01-11 21:50:45 +01:00
function foo(): void {
$foo = ["a", "b", "c"];
foreach ($foo as $bar) {}
unset($foo, $bar);
}',
],
'issetObjectLike' => [
'<?php
$arr = [
"profile" => [
"foo" => "bar",
],
"groups" => [
"foo" => "bar",
"hide" => rand() % 2 > 0,
],
];
foreach ($arr as $item) {
if (!isset($item["hide"]) || !$item["hide"]) {}
}',
],
'issetPropertyAffirmsObject' => [
'<?php
class A {
/** @var ?int */
public $id;
}
function takesA(?A $a): A {
if (isset($a->id)) {
return $a;
}
return new A();
}',
],
'issetVariableKeysWithoutChange' => [
'<?php
$arr = [[1, 2, 3], null, [1, 2, 3], null];
$b = 2;
$c = 0;
if (isset($arr[$b][$c])) {
echo $arr[$b][$c];
}',
],
'issetNonNullArrayKey' => [
'<?php
/**
* @param array<int, int> $arr
*/
function foo(array $arr) : int {
$b = rand(0, 3);
if (!isset($arr[$b])) {
throw new \Exception("bad");
}
return $arr[$b];
}',
],
'issetArrayOffsetConditionalCreationWithInt' => [
'<?php
/** @param array<int, string> $arr */
function foo(array $arr) : string {
if (!isset($arr[0])) {
$arr[0] = "hello";
}
return $arr[0];
}',
],
'issetArrayOffsetConditionalCreationWithVariable' => [
'<?php
/** @param array<int, string> $arr */
function foo(array $arr) : string {
$b = 5;
if (!isset($arr[$b])) {
$arr[$b] = "hello";
}
return $arr[$b];
}',
],
'noExceptionOnBracketString' => [
'<?php
if (isset($foo["bar[]"])) {}',
],
'issetArrayOffsetAndProperty' => [
'<?php
class A {
/** @var ?B */
public $b;
}
class B {}
/**
* @param A[] $arr
*/
function takesAList(array $arr) : B {
if (isset($arr[1]->b)) {
return $arr[1]->b;
}
throw new \Exception("bad");
}',
],
'allowUnknownAdditionToInt' => [
'<?php
$arr = [1, 1, 1, 1, 2, 5, 3, 2];
$cumulative = [];
foreach ($arr as $val) {
if (isset($cumulative[$val])) {
$cumulative[$val] = $cumulative[$val] + 1;
} else {
$cumulative[$val] = 1;
}
}',
],
'allowUnknownArrayMergeToInt' => [
'<?php
$arr = [1, 1, 1, 1, 2, 5, 3, 2];
$cumulative = [];
foreach ($arr as $val) {
if (isset($cumulative[$val])) {
$cumulative[$val] = array_merge($cumulative[$val], [$val]);
} else {
$cumulative[$val] = [$val];
}
}
foreach ($cumulative as $arr) {
foreach ($arr as $val) {
takesInt($val);
}
}
function takesInt(int $i) : void {}',
],
'returnArrayWithDefinedKeys' => [
'<?php
/**
* @param array{bar?: int, foo: int|string} $arr
* @return array{bar: int, foo: string}|null
*/
function foo(array $arr) : ?array {
if (!isset($arr["bar"])) {
return null;
}
if (is_int($arr["foo"])) {
return null;
}
return $arr;
}',
],
'arrayAccessAfterOneIsset' => [
'<?php
$arr = [];
foreach ([1, 2, 3] as $foo) {
if (!isset($arr["bar"])) {
$arr["bar"] = 0;
}
echo $arr["bar"];
}',
],
'arrayAccessAfterTwoIssets' => [
'<?php
$arr = [];
foreach ([1, 2, 3] as $foo) {
if (!isset($arr["foo"])) {
$arr["foo"] = 0;
}
if (!isset($arr["bar"])) {
$arr["bar"] = 0;
}
echo $arr["bar"];
}',
],
'issetAdditionalVar' => [
'<?php
class Example {
const FOO = "foo";
/**
* @param array{bar:string} $params
*/
public function test(array $params) : bool {
if (isset($params[self::FOO])) {
return true;
}
if (isset($params["bat"])) {
return true;
}
return false;
}
2019-03-23 19:27:54 +01:00
}',
],
'noRedundantConditionAfterIsset' => [
'<?php
/** @param array<string, array<int, string>> $arr */
function foo(array $arr, string $k) : void {
if (!isset($arr[$k])) {
return;
}
if ($arr[$k][0]) {}
}',
],
2018-05-31 02:54:03 +02:00
'mixedArrayIsset' => [
'<?php
$a = isset($_GET["a"]) ? $_GET["a"] : "";
if ($a) {}',
'assertions' => [],
'error_levels' => ['MixedAssignment', 'MixedArrayAccess'],
],
'mixedArrayIssetGetStringVar' => [
'<?php
if (isset($_GET["b"]) && is_string($_GET["b"])) {
echo $_GET["b"];
}',
],
'nestedArrayAccessInLoopAfterIsset' => [
'<?php
$arr = [];
while (rand(0, 1)) {
if (rand(0, 1)) {
if (!isset($arr["a"]["b"])) {
$arr["a"]["b"] = "foo";
}
echo $arr["a"]["b"];
} else {
$arr["c"] = "foo";
}
2019-03-23 19:27:54 +01:00
}',
],
2018-06-01 17:16:42 +02:00
'issetVarInLoopBeforeAssignment' => [
'<?php
function foo() : void {
while (rand(0, 1)) {
if (!isset($foo)) {
$foo = 1;
}
}
}',
],
'issetOnArrayAccess' => [
'<?php
function foo(ArrayAccess $arr) : void {
$a = isset($arr["a"]) ? $arr["a"] : "a";
takesInt($a);
}
function takesInt(int $i) : void {}',
'assertions' => [],
'error_levels' => ['MixedAssignment', 'MixedArgument'],
],
'noParadoxOnMultipleNotIssets' => [
'<?php
/** @var array */
$array = [];
function sameString(string $string): string {
return $string;
}
if (isset($array[sameString("key1")]) || isset($array[sameString("key2")])) {
throw new \InvalidArgumentException();
}
if (!isset($array[sameString("key3")]) || !isset($array[sameString("key4")])) {
throw new \InvalidArgumentException();
2019-03-23 19:27:54 +01:00
}',
],
'notIssetOneOrOther' => [
'<?php
$foo = [
"one" => rand(0,1) ? new DateTime : null,
2018-11-06 03:57:36 +01:00
"two" => rand(0,1) ? new DateTime : null,
"three" => new DateTime
];
if (!(isset($foo["one"]) || isset($foo["two"]))) {
exit;
}
echo $foo["one"]->format("Y");',
'assertions' => [],
'error_levels' => ['PossiblyNullReference'],
],
'notIssetOneOrOtherWithoutAssert' => [
'<?php
$foo = [
"one" => rand(0,1) ? new DateTime : null,
2018-11-06 03:57:36 +01:00
"two" => rand(0,1) ? new DateTime : null,
"three" => new DateTime
];
isset($foo["one"]) || isset($foo["two"]);
echo $foo["one"]->format("Y");',
'assertions' => [],
'error_levels' => ['PossiblyNullReference'],
],
'notIssetOneOrOtherWithAssert' => [
'<?php
$foo = [
"one" => rand(0,1) ? new DateTime : null,
2018-11-06 03:57:36 +01:00
"two" => rand(0,1) ? new DateTime : null,
"three" => new DateTime
];
assert(isset($foo["one"]) || isset($foo["two"]));
echo $foo["one"]->format("Y");',
'assertions' => [],
'error_levels' => ['PossiblyNullReference'],
],
'assertArrayAfterIssetStringOffset' => [
'<?php
/**
* @param string|array $a
*/
function _renderInput($a) : array {
if (isset($a["foo"], $a["bar"])) {
return $a;
}
return [];
2019-03-23 19:27:54 +01:00
}',
],
'assertMoreComplicatedArrayAfterIssetStringOffset' => [
'<?php
/**
* @param string|int $val
* @param string|array $text
* @param array $data
*/
function _renderInput($val, $text, $data) : array {
if (is_int($val) && isset($text["foo"], $text["bar"])) {
$radio = $text;
} else {
$radio = ["value" => $val, "text" => $text];
}
return $radio;
}',
'assertions' => [],
'error_levels' => ['MixedAssignment'],
],
'assertAfterIsset' => [
'<?php
/**
* @param mixed $arr
*/
function foo($arr) : void {
if (empty($arr)) {
return;
}
if (isset($arr["a"]) && isset($arr["b"])) {}
}',
'assertions' => [],
'error_levels' => ['MixedAssignment'],
],
2018-12-20 07:06:43 +01:00
'noCrashAfterIsset' => [
'<?php
/**
* @param string[] $columns
* @param mixed[] $options
*/
function foo(array $columns, array $options) : void {
$arr = $options["b"];
foreach ($arr as $a) {
if (isset($columns[$a]["c"])) {
return;
}
}
}',
'assertions' => [],
'error_levels' => ['MixedAssignment', 'MixedArrayOffset', 'InvalidArrayOffset'],
],
'sessionNullCoalesce' => [
'<?php
2019-03-23 19:27:54 +01:00
$a = $_SESSION ?? [];',
],
];
}
/**
2019-03-01 21:55:20 +01:00
* @return iterable<string,array{string,error_message:string,2?:string[],3?:bool,4?:string}>
*/
2018-11-06 03:57:36 +01:00
public function providerInvalidCodeParse()
{
return [
'complainAboutBadCallInIsset' => [
'<?php
class A {}
$a = isset(A::foo()[0]);',
'error_message' => 'UndefinedMethod',
],
'issetVariableKeysWithChange' => [
'<?php
$arr = [[1, 2, 3], null, [1, 2, 3], null];
$b = 2;
$c = 0;
if (isset($arr[$b][$c])) {
$b = 1;
echo $arr[$b][$c];
}',
'error_message' => 'NullArrayAccess',
],
'issetAdditionalVarWithSealedObjectLike' => [
'<?php
class Example {
const FOO = "foo";
public function test() : bool {
$params = ["bar" => "bat"];
if (isset($params[self::FOO])) {
return true;
}
return false;
}
}',
'error_message' => 'InvalidArrayOffset',
],
];
}
}