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

1561 lines
52 KiB
PHP
Raw Normal View History

2016-12-12 05:41:11 +01:00
<?php
2016-12-12 05:41:11 +01:00
namespace Psalm\Tests;
2021-12-03 20:11:20 +01:00
use Psalm\Config;
use Psalm\Context;
2021-12-03 20:29:06 +01:00
use Psalm\Exception\CodeException;
2021-12-04 21:55:53 +01:00
use Psalm\Tests\Traits\InvalidCodeAnalysisTestTrait;
use Psalm\Tests\Traits\ValidCodeAnalysisTestTrait;
2021-12-03 20:11:20 +01:00
use const DIRECTORY_SEPARATOR;
class ArrayAccessTest extends TestCase
2016-12-12 05:41:11 +01:00
{
2021-12-04 21:55:53 +01:00
use InvalidCodeAnalysisTestTrait;
use ValidCodeAnalysisTestTrait;
2016-12-12 05:41:11 +01:00
public function testEnsureArrayOffsetsExist(): void
{
2021-12-03 20:29:06 +01:00
$this->expectException(CodeException::class);
2019-11-11 16:48:14 +01:00
$this->expectExceptionMessage('PossiblyUndefinedStringArrayOffset');
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_string_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
function takesString(string $s): void {}
/** @param array<string, string> $arr */
function takesArrayIteratorOfString(array $arr): void {
echo $arr["hello"];
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testEnsureArrayOffsetsExistWithIssetCheck(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_string_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
function takesString(string $s): void {}
/** @param array<string, string> $arr */
function takesArrayIteratorOfString(array $arr): void {
if (isset($arr["hello"])) {
echo $arr["hello"];
}
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testDontEnsureArrayOffsetsExist(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_string_offsets_exist = false;
$this->addFile(
'somefile.php',
'<?php
function takesString(string $s): void {}
/** @param array<string, string> $arr */
function takesArrayIteratorOfString(array $arr): void {
echo $arr["hello"];
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testEnsureArrayOffsetsExistWithIssetCheckFollowedByIsArray(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_string_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
/** @param array<string, mixed> $s */
function foo(array $s) : void {
if (isset($s["a"]) && \is_array($s["a"])) {}
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testComplainAfterFirstIsset(): void
2019-10-04 03:34:56 +02:00
{
2021-12-03 20:29:06 +01:00
$this->expectException(CodeException::class);
2019-11-11 16:48:14 +01:00
$this->expectExceptionMessage('PossiblyUndefinedStringArrayOffset');
2019-10-04 03:34:56 +02:00
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_string_offsets_exist = true;
2019-10-04 03:34:56 +02:00
$this->addFile(
'somefile.php',
'<?php
function foo(array $arr) : void {
if (isset($arr["a"]) && $arr["b"]) {}
2022-12-18 17:15:15 +01:00
}',
2019-10-04 03:34:56 +02:00
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
2019-10-04 03:34:56 +02:00
}
public function testEnsureArrayIntOffsetsExist(): void
{
2021-12-03 20:29:06 +01:00
$this->expectException(CodeException::class);
2019-11-11 16:48:14 +01:00
$this->expectExceptionMessage('PossiblyUndefinedIntArrayOffset');
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
function takesString(string $s): void {}
/** @param array<int, string> $arr */
function takesArrayIteratorOfString(array $arr): void {
echo $arr[4];
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testNoIssueWhenUsingArrayValuesOnNonEmptyArray(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
/** @param string[][] $arr */
function foo(array $arr) : void {
if (count($arr) === 1 && count(array_values($arr)[0]) === 1) {}
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
2023-02-22 23:11:10 +01:00
public function testNoIssueWhenUsingArrayValuesOnNonEmptyArrayCheckedWithSizeof(): void
{
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
/** @param string[][] $arr */
function foo(array $arr) : void {
if (sizeof($arr) === 1 && sizeof(array_values($arr)[0]) === 1) {}
}',
);
$this->analyzeFile('somefile.php', new Context());
}
public function testNoIssueAfterManyIssets(): void
2019-10-17 06:29:51 +02:00
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
2019-10-17 06:29:51 +02:00
$this->addFile(
'somefile.php',
'<?php
/**
* @return mixed
*/
function f(array $a) {
if (isset($a[1])
&& is_array($a[1])
&& isset($a[1][2])
) {
return $a[1][2];
}
2022-12-18 17:15:15 +01:00
}',
2019-10-17 06:29:51 +02:00
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
2019-10-17 06:29:51 +02:00
}
public function testEnsureListOffsetExistsNotEmpty(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
/** @param list<string> $arr */
function takesList(array $arr) : void {
if ($arr) {
echo $arr[0];
}
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testEnsureListOffsetExistsAfterArrayPop(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
2021-12-03 20:29:06 +01:00
$this->expectException(CodeException::class);
2019-11-11 16:48:14 +01:00
$this->expectExceptionMessage('PossiblyUndefinedIntArrayOffset');
$this->addFile(
'somefile.php',
'<?php
/** @param list<string> $arr */
function takesList(array $arr) : void {
if ($arr) {
echo $arr[0];
array_pop($arr);
echo $arr[0];
}
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testEnsureOffsetExistsAfterArrayPush(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
$a = [1, 2, 3];
array_push($a, 4);
2022-12-18 17:15:15 +01:00
echo $a[3];',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testEnsureOffsetExistsAfterNestedIsset(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_string_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
class A {
public int $foo = 0;
}
/**
* @param array<string, A> $value
*/
function test(array $value): int
{
return isset($value["a"]->foo) ? $value["a"]->foo : 0;
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testEnsureListOffsetExistsAfterCountValueInRange(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
/** @param list<string> $arr */
function takesList(array $arr) : void {
if (count($arr) >= 3) {
echo $arr[0];
echo $arr[1];
echo $arr[2];
}
if (count($arr) > 2) {
echo $arr[0];
echo $arr[1];
echo $arr[2];
}
if (count($arr) === 3) {
echo $arr[0];
echo $arr[1];
echo $arr[2];
}
if (3 === count($arr)) {
echo $arr[0];
echo $arr[1];
echo $arr[2];
}
if (3 <= count($arr)) {
echo $arr[0];
echo $arr[1];
echo $arr[2];
}
if (2 < count($arr)) {
echo $arr[0];
echo $arr[1];
echo $arr[2];
}
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testCountOnKeyedArrayInRange(): void
{
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
/** @param non-empty-list<string> $list */
function bar(array $list) : void {
if (rand(0, 1)) {
$list = ["a"];
}
if (count($list) > 1) {
echo $list[1];
}
2022-12-18 17:15:15 +01:00
}',
);
$this->analyzeFile('somefile.php', new Context());
}
public function testCountOnKeyedArrayInRangeWithUpdate(): void
{
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
/** @param non-empty-list<string> $list */
function bar(array $list) : void {
if (rand(0, 1)) {
$list = ["a"];
}
if (count($list) > 1) {
if ($list[1][0] === "a") {
$list[1] = "foo";
}
echo $list[1];
}
2022-12-18 17:15:15 +01:00
}',
);
$this->analyzeFile('somefile.php', new Context());
}
public function testCountOnKeyedArrayOutOfRange(): void
{
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->expectException(CodeException::class);
$this->expectExceptionMessage('PossiblyUndefinedIntArrayOffset');
$this->addFile(
'somefile.php',
'<?php
/** @param non-empty-list<string> $list */
function bar(array $list) : void {
if (rand(0, 1)) {
$list = ["a"];
}
if (count($list) > 1) {
echo $list[2];
}
2022-12-18 17:15:15 +01:00
}',
);
$this->analyzeFile('somefile.php', new Context());
}
public function testEnsureListOffsetExistsAfterCountValueOutOfRange(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
2021-12-03 20:29:06 +01:00
$this->expectException(CodeException::class);
$this->expectExceptionMessage('PossiblyUndefinedIntArrayOffset');
$this->addFile(
'somefile.php',
'<?php
/** @param list<string> $arr */
function takesList(array $arr) : void {
if (count($arr) >= 2) {
echo $arr[0];
echo $arr[1];
echo $arr[2];
}
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testEnsureListOffsetExistsAfterCountValueOutOfRangeSmallerThan(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
2021-12-03 20:29:06 +01:00
$this->expectException(CodeException::class);
$this->expectExceptionMessage('PossiblyUndefinedIntArrayOffset');
$this->addFile(
'somefile.php',
'<?php
/** @param list<string> $arr */
function takesList(array $arr) : void {
if (2 <= count($arr)) {
echo $arr[0];
echo $arr[1];
echo $arr[2];
}
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testDontWorryWhenUnionedWithPositiveInt(): void
{
2021-12-03 20:11:20 +01:00
Config::getInstance()->ensure_array_int_offsets_exist = true;
$this->addFile(
'somefile.php',
'<?php
/**
* @param list<string> $a
* @param 0|positive-int $b
*/
function foo(array $a, int $b): void {
echo $a[$b];
2022-12-18 17:15:15 +01:00
}',
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function providerValidCodeParse(): iterable
2016-12-12 05:41:11 +01:00
{
return [
2022-12-19 12:55:32 +01:00
'testBuildList' => [
'code' => '<?php
$a = [];
if (random_int(0, 1)) {
$a []= 0;
}
if (random_int(0, 1)) {
$a []= 1;
}
$pre = $a;
$a []= 2;
',
'assertions' => [
'$pre===' => 'list{0?: 0|1, 1?: 1}',
'$a===' => 'list{0: 0|1|2, 1?: 1|2, 2?: 2}',
2022-12-19 13:04:24 +01:00
],
2022-12-19 12:55:32 +01:00
],
'testBuildListOther' => [
'code' => '<?php
$list = [];
$entropy = random_int(0, 2);
if ($entropy === 0) {
$list[] = "A";
} elseif ($entropy === 1) {
$list[] = "B";
}
$list[] = "C";
',
'assertions' => [
2022-12-19 13:04:24 +01:00
'$list===' => "list{0: 'A'|'B'|'C', 1?: 'C'}",
],
2022-12-19 12:55:32 +01:00
],
2022-12-19 21:11:10 +01:00
'testBuildList3' => [
'code' => '<?php
$a = [0];
if (random_int(0, 1)) {
$a []= 1;
}
if (random_int(0, 1)) {
$a []= 2;
}
$a []= 3;
',
'assertions' => [
2022-12-19 21:25:06 +01:00
'$a===' => "list{0: 0, 1: 1|2|3, 2?: 2|3, 3?: 3}",
2022-12-19 21:11:10 +01:00
],
],
'instanceOfStringOffset' => [
'code' => '<?php
class A {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void { }
}
2018-01-11 21:50:45 +01:00
function bar (array $a): void {
if ($a["a"] instanceof A) {
$a["a"]->fooFoo();
}
2017-05-27 02:05:57 +02:00
}',
],
'instanceOfIntOffset' => [
'code' => '<?php
class A {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void { }
}
2018-01-11 21:50:45 +01:00
function bar (array $a): void {
if ($a[0] instanceof A) {
$a[0]->fooFoo();
}
2017-05-27 02:05:57 +02:00
}',
],
'nonEmptyStringAccess' => [
'code' => '<?php
/** @var non-empty-string $a */
$a = "blah";
$b = $a[0];',
'assertions' => [
'$b===' => 'non-empty-string',
],
],
'notEmptyStringOffset' => [
'code' => '<?php
/**
* @param array<string> $a
*/
2018-01-11 21:50:45 +01:00
function bar (array $a): string {
if ($a["bat"]) {
return $a["bat"];
}
return "blah";
2017-05-27 02:05:57 +02:00
}',
],
'issetPropertyStringOffset' => [
'code' => '<?php
class A {
/** @var array<string, string> */
public $arr = [];
}
$a = new A();
if (!isset($a->arr["bat"]) || strlen($a->arr["bat"])) { }',
],
'issetPropertyStringOffsetUndefinedClass' => [
'code' => '<?php
/** @psalm-suppress UndefinedClass */
$a = new A();
2020-12-02 02:10:48 +01:00
/**
* @psalm-suppress UndefinedClass
*/
if (!isset($a->arr["bat"]) || strlen($a->arr["bat"])) { }',
'assertions' => [],
'ignored_issues' => ['MixedArgument', 'MixedArrayAccess'],
],
'notEmptyIntOffset' => [
'code' => '<?php
/**
* @param array<string> $a
*/
2018-01-11 21:50:45 +01:00
function bar (array $a): string {
if ($a[0]) {
return $a[0];
}
return "blah";
2017-05-27 02:05:57 +02:00
}',
],
'ignorePossiblyNullArrayAccess' => [
'code' => '<?php
$a = rand(0, 1) ? [1, 2] : null;
echo $a[0];',
'assertions' => [],
'ignored_issues' => ['PossiblyNullArrayAccess'],
2017-05-27 02:05:57 +02:00
],
'ignoreEmptyArrayAccess' => [
'code' => '<?php
$arr = [];
$x = $arr[0];
if (isset($arr[0]) && $arr[0]) { }',
'assertions' => [
2017-06-29 16:22:49 +02:00
'$x' => 'mixed',
],
'ignored_issues' => ['EmptyArrayAccess', 'MixedAssignment'],
],
'objectLikeWithoutKeys' => [
'code' => '<?php
2018-01-11 21:50:45 +01:00
function takesInt(int $i): void {}
function takesString(string $s): void {}
function takesBool(bool $b): void {}
/**
* @param array{int, string, bool} $b
*/
2018-01-11 21:50:45 +01:00
function a(array $b): void {
takesInt($b[0]);
takesString($b[1]);
takesBool($b[2]);
}',
],
'stringKeysWithInts' => [
'code' => '<?php
$array = ["01" => "01", "02" => "02"];
foreach ($array as $key => $value) {
$len = strlen($key);
}',
],
2018-03-21 13:48:30 +01:00
'listAssignmentKeyOffset' => [
'code' => '<?php
2018-03-21 13:48:30 +01:00
$a = [];
list($a["foo"]) = explode("+", "a+b");
echo $a["foo"];',
],
'objectlikeOptionalNamespacedParam' => [
'code' => '<?php
namespace N;
/**
* @psalm-param array{key?:string} $p
*/
function f(array $p): void
{
echo isset($p["key"]) ? $p["key"] : "";
}',
],
'unsetTKeyedArrayOffset' => [
'code' => '<?php
2022-10-03 15:13:47 +02:00
$x1 = ["a" => "value"];
unset($x1["a"]);
$x2 = ["a" => "value", "b" => "value"];
unset($x2["a"]);
$x3 = ["a" => "value", "b" => "value"];
$k = "a";
unset($x3[$k]);',
'assertions' => [
'$x1===' => 'array<never, never>',
'$x2===' => "array{b: 'value'}",
'$x3===' => "array{b: 'value'}",
2022-12-18 17:15:15 +01:00
],
],
'possiblyUndefinedArrayOffsetKeyedArray' => [
'code' => '<?php
$d = [];
if (!rand(0,1)) {
$d[0] = "a";
}
$x = $d[0];',
'assertions' => [
2024-01-12 23:37:45 +01:00
'$x===' => '\'a\'',
],
'ignored_issues' => ['PossiblyUndefinedArrayOffset'],
],
'domNodeListAccessible' => [
'code' => '<?php
$doc = new DOMDocument();
$doc->loadXML("<node key=\"value\"/>");
$e = $doc->getElementsByTagName("node")[0];',
'assertions' => [
'$e' => 'DOMElement|null',
2019-03-23 19:27:54 +01:00
],
],
'getOnArrayAcccess' => [
'code' => '<?php
/** @param ArrayAccess<int, string> $a */
function foo(ArrayAccess $a) : string {
return $a[0];
}',
],
'mixedKeyMixedOffset' => [
'code' => '<?php
function example(array $x, $y) : void {
echo $x[$y];
}',
'assertions' => [],
'ignored_issues' => ['MixedArgument', 'MixedArrayOffset', 'MissingParamType'],
],
2024-01-13 13:05:43 +01:00
'suppressPossiblyUndefinedStringArrayOffset' => [
'code' => '<?php
/** @var array{a?:string} */
$entry = ["a"];
["a" => $elt] = $entry;
strlen($elt);
strlen($entry["a"]);',
'assertions' => [],
'ignored_issues' => ['PossiblyUndefinedArrayOffset'],
],
2018-12-11 00:33:26 +01:00
'noRedundantConditionOnMixedArrayAccess' => [
'code' => '<?php
2018-12-11 00:33:26 +01:00
/** @var array<int, int> */
$b = [];
/** @var array<int, int> */
$c = [];
/** @var array<int, mixed> */
$d = [];
if (!empty($d[0]) && !isset($c[$d[0]])) {
if (isset($b[$d[0]])) {}
}',
'assertions' => [],
'ignored_issues' => ['MixedArrayOffset'],
2018-12-11 00:33:26 +01:00
],
'noEmptyArrayAccessInLoop' => [
'code' => '<?php
/**
* @psalm-suppress MixedAssignment
* @psalm-suppress MixedOperand
* @psalm-suppress MixedArrayAssignment
* @param mixed[] $line
*/
function _renderCells(array $line): void {
foreach ($line as $cell) {
$cellOptions = [];
if (is_array($cell)) {
$cellOptions = $cell[1];
}
if (isset($cellOptions[0])) {
$cellOptions[0] = $cellOptions[0] . "b";
} else {
$cellOptions[0] = "b";
}
}
2019-03-23 19:27:54 +01:00
}',
],
2018-12-19 06:28:11 +01:00
'arrayAccessPropertyAssertion' => [
'code' => '<?php
2018-12-19 06:28:11 +01:00
class A {}
class B extends A {
/** @var array<int, string> */
public $arr = [];
}
/** @var array<A> */
$as = [];
if (!$as
|| !$as[0] instanceof B
|| !$as[0]->arr
) {
return null;
}
$b = $as[0]->arr;',
],
2018-12-21 19:53:22 +01:00
'arrayAccessAfterPassByref' => [
'code' => '<?php
2018-12-21 19:53:22 +01:00
class Arr {
/**
* @param mixed $c
* @return mixed
*/
public static function pull(array &$a, string $b, $c = null) {
return $a[$b] ?? $c;
}
}
function _renderButton(array $settings): void {
Arr::pull($settings, "a", true);
if (isset($settings["b"])) {
Arr::pull($settings, "b");
}
if (isset($settings["c"])) {}
2019-03-23 19:27:54 +01:00
}',
2018-12-21 19:53:22 +01:00
],
'arrayKeyChecks' => [
'code' => '<?php
/**
* @param string[] $arr
*/
function foo(array $arr) : void {
if (!$arr) {
return;
}
foreach ($arr as $i => $_) {}
if ($i === "hello") {}
if ($i !== "hello") {}
if ($i === 5) {}
if ($i !== 5) {}
if (is_string($i)) {}
if (is_int($i)) {}
foreach ($arr as $i => $_) {}
if ($i === "hell") {
$i = "hellp";
}
if ($i === "hel") {}
}',
],
'arrayKeyChecksAfterDefinition' => [
'code' => '<?php
/**
* @param string[] $arr
*/
function foo(array $arr) : void {
if (!$arr) {
return;
}
foreach ($arr as $i => $_) {}
if ($i === "hell") {
$i = "hellp";
}
if ($i === "hel") {}
}',
],
2019-03-23 19:27:54 +01:00
'allowMixedTypeCoercionArrayKeyAccess' => [
'code' => '<?php
/**
* @param array<array-key, int> $i
* @param array<int, string> $arr
*/
function foo(array $i, array $arr) : void {
foreach ($i as $j => $k) {
echo $arr[$j];
}
}',
'assertions' => [],
'ignored_issues' => ['MixedArrayTypeCoercion'],
],
2019-03-23 19:27:54 +01:00
'allowNegativeStringOffset' => [
'code' => '<?php
$a = "hello";
echo $a[-5];
echo $a[-4];
echo $a[-3];
echo $a[-2];
echo $a[-1];
echo $a[0];
echo $a[1];
echo $a[2];
echo $a[3];
echo $a[4];',
],
'arrayAccessAfterPossibleGeneralisation' => [
'code' => '<?php
function getArray() : array { return []; }
$params = array(
"a" => 1,
"b" => [
"c" => "a",
]
);
if (rand(0, 1)) {
$params = getArray();
}
echo $params["b"]["c"];',
'assertions' => [],
'ignored_issues' => ['MixedArrayAccess', 'MixedArgument'],
],
'arrayAccessOnObjectWithNullGet' => [
'code' => '<?php
2020-12-02 03:12:03 +01:00
$array = new C([]);
$array["key"] = [];
/** @psalm-suppress PossiblyInvalidArrayAssignment */
$array["key"][] = "testing";
$c = isset($array["foo"]) ? $array["foo"] : null;
/**
* @psalm-suppress MissingTemplateParam
*/
class C implements ArrayAccess
{
/**
* @var array<C|scalar>
*/
protected $data = [];
/**
* @param array<scalar|array> $array
* @psalm-suppress MixedArgumentTypeCoercion
*/
final public function __construct(array $array)
{
foreach ($array as $key => $value) {
if (is_array($value)) {
$this->data[$key] = new static($value);
} else {
$this->data[$key] = $value;
}
}
}
/**
* @param string $name
* @return C|scalar
*/
public function offsetGet($name)
{
return $this->data[$name];
}
/**
* @param ?string $offset
* @param scalar|array $value
* @psalm-suppress MixedArgumentTypeCoercion
*/
public function offsetSet($offset, $value) : void
{
if (is_array($value)) {
$value = new static($value);
}
if (null === $offset) {
$this->data[] = $value;
} else {
$this->data[$offset] = $value;
}
}
public function __isset(string $name) : bool
{
return isset($this->data[$name]);
}
public function __unset(string $name) : void
{
unset($this->data[$name]);
}
/**
* @psalm-suppress MixedArgument
*/
public function offsetExists($offset) : bool
{
return $this->__isset($offset);
}
/**
* @psalm-suppress MixedArgument
*/
public function offsetUnset($offset) : void
{
$this->__unset($offset);
}
2020-12-02 03:12:03 +01:00
}',
'assertions' => [
'$c' => 'C|null|scalar',
2022-12-18 17:15:15 +01:00
],
],
2019-04-26 15:35:16 +02:00
'singleLetterOffset' => [
'code' => '<?php
2019-04-26 15:35:16 +02:00
["s" => "str"]["str"[0]];',
],
2019-06-08 16:32:40 +02:00
'arrayAccessAfterByRefArrayOffsetAssignment' => [
'code' => '<?php
2019-06-08 16:32:40 +02:00
/**
* @param array{param1: array} $params
2019-06-08 16:32:40 +02:00
*/
function dispatch(array $params) : void {
$params["param1"]["foo"] = "bar";
}
$ar = [];
dispatch(["param1" => &$ar]);
$value = "foo";
if (isset($ar[$value])) {
echo (string) $ar[$value];
}',
'assertions' => [],
'ignored_issues' => ['MixedArrayAccess'],
2019-06-08 16:32:40 +02:00
],
'byRefArrayAccessWithoutKnownVarNoNotice' => [
'code' => '<?php
$a = new stdClass();
/** @psalm-suppress MixedPropertyFetch */
print_r([&$a->foo->bar]);',
],
2019-10-09 00:44:46 +02:00
'accessOffsetOnList' => [
'code' => '<?php
2019-10-09 00:44:46 +02:00
/** @param list<int> $arr */
function foo(array $arr) : void {
echo $arr[3] ?? null;
}',
],
2020-02-07 05:52:27 +01:00
'destructureMixed' => [
'code' => '<?php
2020-02-07 05:52:27 +01:00
class S {
protected array $a = [];
protected array $b = [];
protected array $c = [];
/**
* @psalm-suppress MixedAssignment
*/
public function pop(): void {
if (!$this->a) {
return;
}
$popped = array_pop($this->a);
/** @psalm-suppress MixedArrayAccess */
2020-02-07 05:52:27 +01:00
[$this->b, $this->c] = $popped;
}
2022-12-18 17:15:15 +01:00
}',
2020-02-07 05:52:27 +01:00
],
'simpleXmlArrayFetch' => [
'code' => '<?php
function foo(SimpleXMLElement $s) : ?SimpleXMLElement {
return $s["a"];
}',
],
'simpleXmlArrayFetchChildren' => [
'code' => '<?php
function iterator(SimpleXMLElement $xml): iterable {
2022-06-22 08:53:42 +02:00
$children = $xml->children();
assert($children !== null);
foreach ($children as $img) {
yield $img["src"] ?? "";
}
}',
],
'assertOnArrayAccess' => [
'code' => '<?php
class A {
public function foo() : void {}
}
/**
* @psalm-suppress MissingTemplateParam
*/
class C implements ArrayAccess
{
/**
* @var array
*/
protected $data = [];
/**
* @param string $name
* @return mixed
*/
public function offsetGet($name)
{
return $this->data[$name];
}
/**
* @param string $offset
* @param mixed $value
*/
public function offsetSet($offset, $value) : void
{
$this->data[$offset] = $value;
}
public function __isset(string $name) : bool
{
return isset($this->data[$name]);
}
public function __unset(string $name) : void
{
unset($this->data[$name]);
}
/**
* @psalm-suppress MixedArgument
*/
public function offsetExists($offset) : bool
{
return $this->__isset($offset);
}
/**
* @psalm-suppress MixedArgument
*/
public function offsetUnset($offset) : void
{
$this->__unset($offset);
}
}
$container = new C();
if ($container["a"] instanceof A) {
$container["a"]->foo();
2022-12-18 17:15:15 +01:00
}',
],
'assignmentListCheckForNull' => [
'code' => '<?php
/**
* @return array{0: int, 1:string}|null
*/
function bar(int $i) {
if ( $i < 0)
return [$i, "hello"];
else
return null;
}
/** @psalm-suppress PossiblyNullArrayAccess */
[1 => $foo] = bar(0);
2022-12-18 17:15:15 +01:00
if ($foo !== null) {}',
],
2022-01-23 22:05:38 +01:00
'SKIPPED-accessKnownArrayWithPositiveInt' => [
'code' => '<?php
/** @param list<int> $arr */
function foo(array $arr) : void {
$o = [4, 15, 18, 21, 51];
$i = 0;
foreach ($arr as $a) {
if ($o[$i] === $a) {}
$i++;
}
2022-12-18 17:15:15 +01:00
}',
],
'arrayAccessOnArraylikeObjectOrArray' => [
'code' => '<?php
/**
* @param arraylike-object<int, string>|array<int, string> $arr
*/
function test($arr): string {
2020-11-26 02:04:57 +01:00
return $arr[0];
}
test(["a", "b"]);
2022-12-18 17:15:15 +01:00
test(new ArrayObject(["a", "b"]));',
],
'nullCoalesceArrayAccess' => [
'code' => '<?php
/** @param ArrayAccess<int, string> $a */
function foo(?ArrayAccess $a) : void {
echo $a[0] ?? "default";
2022-12-18 17:15:15 +01:00
}',
],
'allowUnsettingNested' => [
'code' => '<?php
/** @psalm-immutable */
final class test {
public function __construct(public int $value) {}
}
$test = new test(1);
$a = [1 => $test];
2022-12-18 17:15:15 +01:00
unset($a[$test->value]);',
],
2020-12-02 02:10:48 +01:00
'arrayAssertionShouldNotBeNull' => [
'code' => '<?php
2020-12-02 02:10:48 +01:00
function foo(?array $arr, string $s) : void {
/**
* @psalm-suppress PossiblyNullArrayAccess
* @psalm-suppress MixedArrayAccess
*/
if ($arr[$s]["b"] !== true) {
return;
}
/**
* @psalm-suppress MixedArgument
* @psalm-suppress MixedArrayAccess
* @psalm-suppress PossiblyNullArrayAccess
*/
echo $arr[$s]["c"];
2022-12-18 17:15:15 +01:00
}',
2020-12-02 02:10:48 +01:00
],
'TransformBadOffsetToGoodOnes' => [
'code' => '<?php
$index = 1.1;
/** @psalm-suppress InvalidArrayOffset */
$_arr1 = [$index => 5];
$_arr2 = [];
/** @psalm-suppress InvalidArrayOffset */
$_arr2[$index] = 5;',
'assertions' => [
'$_arr1===' => 'non-empty-array<1, 5>',
'$_arr2===' => 'array{1: 5}',
2022-12-18 17:15:15 +01:00
],
],
'accessArrayWithSingleStringLiteralOffset' => [
'code' => '<?php
/** @param non-empty-array<"name", int> $p */
function f($p): int {
return $p["name"];
2022-12-18 17:15:15 +01:00
}',
],
'unsetListKeyedArrayDisableListFlag' => [
'code' => '<?php
$a = ["a", "b"];
unset($a[0]);
',
2022-12-18 17:15:15 +01:00
'assertions' => ['$a===' => "array{1: 'b'}"],
],
'noCrashOnUnknownClassArrayAccess' => [
'code' => <<<'PHP'
<?php
namespace Psalmtest\Psalmtest;
use SomeMissingClass;
class Test
{
public function f(): void {
/** @var SomeMissingClass */
$result = null;
if ($result['errors'] === true) {}
}
}
PHP,
'assertions' => [],
'ignored_issues' => ['UndefinedDocblockClass'],
],
];
2016-12-12 05:41:11 +01:00
}
public function providerInvalidCodeParse(): iterable
{
return [
'invalidArrayAccess' => [
'code' => '<?php
$a = 5;
echo $a[0];',
2017-05-27 02:05:57 +02:00
'error_message' => 'InvalidArrayAccess',
],
'invalidArrayOffset' => [
'code' => '<?php
$x = ["a"];
$y = $x["b"];',
'error_message' => 'InvalidArrayOffset',
],
'possiblyInvalidArrayOffsetWithInt' => [
'code' => '<?php
$x = rand(0, 5) > 2 ? ["a" => 5] : "hello";
$y = $x[0];',
'error_message' => 'PossiblyInvalidArrayOffset',
],
'possiblyInvalidArrayOffsetWithString' => [
'code' => '<?php
$x = rand(0, 5) > 2 ? ["a" => 5] : "hello";
$y = $x["a"];',
'error_message' => 'PossiblyInvalidArrayOffset',
],
'possiblyInvalidArrayAccessWithNestedArray' => [
'code' => '<?php
/**
* @return array<int,array<string,float>>|string
*/
function return_array() {
return rand() % 5 > 3 ? [["key" => 3.5]] : "key:3.5";
}
$result = return_array();
$v = $result[0]["key"];',
'error_message' => 'PossiblyInvalidArrayOffset',
],
'possiblyInvalidArrayAccess' => [
'code' => '<?php
$a = rand(0, 10) > 5 ? 5 : ["hello"];
echo $a[0];',
'error_message' => 'PossiblyInvalidArrayAccess',
],
'mixedArrayAccess' => [
'code' => '<?php
/** @var mixed */
$a = [];
echo $a[0];',
'error_message' => 'MixedArrayAccess',
Add support for strict arrays, fix type alias intersection, fix array_is_list assertion on non-lists (#8395) * Immutable CodeLocation * Remove excess clones * Remove external clones * Remove leftover clones * Fix final clone issue * Immutable storages * Refactoring * Fixes * Fixes * Fix * Fix * Fixes * Simplify * Fixes * Fix * Fixes * Update * Fix * Cache global types * Fix * Update * Update * Fixes * Fixes * Refactor * Fixes * Fix * Fix * More caching * Fix * Fix * Update * Update * Fix * Fixes * Update * Refactor * Update * Fixes * Break one more test * Fix * FIx * Fix * Fix * Fix * Fix * Improve performance and readability * Equivalent logic * Fixes * Revert * Revert "Revert" This reverts commit f9175100c8452c80559234200663fd4c4f4dd889. * Fix * Fix reference bug * Make default TypeVisitor immutable * Bugfix * Remove clones * Partial refactoring * Refactoring * Fixes * Fix * Fixes * Fixes * cs-fix * Fix final bugs * Add test * Misc fixes * Update * Fixes * Experiment with removing different property * revert "Experiment with removing different property" This reverts commit ac1156e077fc4ea633530d51096d27b6e88bfdf9. * Uniform naming * Uniform naming * Hack hotfix * Clean up $_FILES ref #8621 * Undo hack, try fixing properly * Helper method * Remove redundant call * Partially fix bugs * Cleanup * Change defaults * Fix bug * Fix (?, hope this doesn't break anything else) * cs-fix * Review fixes * Bugfix * Bugfix * Improve logic * Add support for list{} and callable-list{} types, properly implement array_is_list assertions (fixes #8389) * Default to sealed arrays * Fix array_merge bug * Fixes * Fix * Sealed type checks * Properly infer properties-of and get_object_vars on final classes * Fix array_map zipping * Fix tests * Fixes * Fixes * Fix more stuff * Recursively resolve type aliases * Fix typo * Fixes * Fix array_is_list assertion on keyed array * Add BC docs * Fixes * fix * Update * Update * Update * Update * Seal arrays with count assertions * Fix #8528 * Fix * Update * Improve sealed array foreach logic * get_object_vars on template properties * Fix sealed array assertion reconciler logic * Improved reconciler * Add tests * Single source of truth for test types * Fix tests * Fixup tests * Fixup tests * Fixup tests * Update * Fix tests * Fix tests * Final fixes * Fixes * Use list syntax only when needed * Fix tests * Cs-fix * Update docs * Update docs * Update docs * Update docs * Update docs * Document missing types * Update docs * Improve class-string-map docs * Update * Update * I love working on psalm :) * Keep arrays unsealed by default * Fixup tests * Fix syntax mistake * cs-fix * Fix typo * Re-import missing types * Keep strict types only in return types * argc/argv fixes * argc/argv fixes * Fix test * Comment-out valinor code, pinging @romm pls merge https://github.com/CuyZ/Valinor/pull/246 so we can add valinor to the psalm docs :)
2022-11-05 22:34:42 +01:00
'ignored_issues' => ['MixedAssignment'],
],
'mixedArrayOffset' => [
'code' => '<?php
/** @var mixed */
$a = 5;
echo [1, 2, 3, 4][$a];',
'error_message' => 'MixedArrayOffset',
Add support for strict arrays, fix type alias intersection, fix array_is_list assertion on non-lists (#8395) * Immutable CodeLocation * Remove excess clones * Remove external clones * Remove leftover clones * Fix final clone issue * Immutable storages * Refactoring * Fixes * Fixes * Fix * Fix * Fixes * Simplify * Fixes * Fix * Fixes * Update * Fix * Cache global types * Fix * Update * Update * Fixes * Fixes * Refactor * Fixes * Fix * Fix * More caching * Fix * Fix * Update * Update * Fix * Fixes * Update * Refactor * Update * Fixes * Break one more test * Fix * FIx * Fix * Fix * Fix * Fix * Improve performance and readability * Equivalent logic * Fixes * Revert * Revert "Revert" This reverts commit f9175100c8452c80559234200663fd4c4f4dd889. * Fix * Fix reference bug * Make default TypeVisitor immutable * Bugfix * Remove clones * Partial refactoring * Refactoring * Fixes * Fix * Fixes * Fixes * cs-fix * Fix final bugs * Add test * Misc fixes * Update * Fixes * Experiment with removing different property * revert "Experiment with removing different property" This reverts commit ac1156e077fc4ea633530d51096d27b6e88bfdf9. * Uniform naming * Uniform naming * Hack hotfix * Clean up $_FILES ref #8621 * Undo hack, try fixing properly * Helper method * Remove redundant call * Partially fix bugs * Cleanup * Change defaults * Fix bug * Fix (?, hope this doesn't break anything else) * cs-fix * Review fixes * Bugfix * Bugfix * Improve logic * Add support for list{} and callable-list{} types, properly implement array_is_list assertions (fixes #8389) * Default to sealed arrays * Fix array_merge bug * Fixes * Fix * Sealed type checks * Properly infer properties-of and get_object_vars on final classes * Fix array_map zipping * Fix tests * Fixes * Fixes * Fix more stuff * Recursively resolve type aliases * Fix typo * Fixes * Fix array_is_list assertion on keyed array * Add BC docs * Fixes * fix * Update * Update * Update * Update * Seal arrays with count assertions * Fix #8528 * Fix * Update * Improve sealed array foreach logic * get_object_vars on template properties * Fix sealed array assertion reconciler logic * Improved reconciler * Add tests * Single source of truth for test types * Fix tests * Fixup tests * Fixup tests * Fixup tests * Update * Fix tests * Fix tests * Final fixes * Fixes * Use list syntax only when needed * Fix tests * Cs-fix * Update docs * Update docs * Update docs * Update docs * Update docs * Document missing types * Update docs * Improve class-string-map docs * Update * Update * I love working on psalm :) * Keep arrays unsealed by default * Fixup tests * Fix syntax mistake * cs-fix * Fix typo * Re-import missing types * Keep strict types only in return types * argc/argv fixes * argc/argv fixes * Fix test * Comment-out valinor code, pinging @romm pls merge https://github.com/CuyZ/Valinor/pull/246 so we can add valinor to the psalm docs :)
2022-11-05 22:34:42 +01:00
'ignored_issues' => ['MixedAssignment'],
],
'nullArrayAccess' => [
'code' => '<?php
$a = null;
echo $a[0];',
2017-05-27 02:05:57 +02:00
'error_message' => 'NullArrayAccess',
],
'possiblyNullArrayAccess' => [
'code' => '<?php
$a = rand(0, 1) ? [1, 2] : null;
echo $a[0];',
2017-05-27 02:05:57 +02:00
'error_message' => 'PossiblyNullArrayAccess',
],
'specificErrorMessage' => [
'code' => '<?php
$params = ["key" => "value"];
echo $params["fieldName"];',
2019-02-27 22:00:44 +01:00
'error_message' => 'InvalidArrayOffset - src' . DIRECTORY_SEPARATOR . 'somefile.php:3:26 - Cannot access '
. 'value on variable $params using offset value of',
],
'missingArrayOffsetAfterUnset' => [
'code' => '<?php
$x = ["a" => "value", "b" => "value"];
unset($x["a"]);
echo $x["a"];',
'error_message' => 'InvalidArrayOffset',
],
'noImpossibleStringAccess' => [
'code' => '<?php
function foo(string $s) : void {
echo $s[0][1];
}',
'error_message' => 'InvalidArrayOffset',
],
'mixedKeyStdClassOffset' => [
'code' => '<?php
function example(array $y) : void {
echo $y[new stdClass()];
}',
'error_message' => 'InvalidArrayOffset',
],
'toStringOffset' => [
'code' => '<?php
class Foo {
public function __toString() {
return "Foo";
}
}
$a = ["Foo" => "bar"];
echo $a[new Foo];',
'error_message' => 'InvalidArrayOffset',
],
2024-01-12 23:37:45 +01:00
'possiblyUndefinedIntArrayOffset' => [
'code' => '<?php
/** @var array{0?:string} */
$entry = ["a"];
[$elt] = $entry;',
'error_message' => 'PossiblyUndefinedArrayOffset',
],
2024-01-12 23:37:45 +01:00
'possiblyUndefinedStringArrayOffset' => [
'code' => '<?php
/** @var array{a?:string} */
$entry = ["a"];
["a" => $elt] = $entry;',
'error_message' => 'PossiblyUndefinedArrayOffset',
],
'possiblyInvalidMixedArrayOffset' => [
'code' => '<?php
/**
* @param string|array $key
*/
function foo(array $a, $key) : void {
echo $a[$key];
}',
'error_message' => 'PossiblyInvalidArrayOffset',
],
'arrayAccessOnIterable' => [
'code' => '<?php
function foo(iterable $i) {
echo $i[0];
}',
'error_message' => 'InvalidArrayAccess',
],
'arrayKeyCannotBeBool' => [
'code' => '<?php
/**
* @param string[] $arr
*/
function foo(array $arr) : void {
if (!$arr) {
return;
}
foreach ($arr as $i => $_) {}
if ($i === false) {}
}',
'error_message' => 'TypeDoesNotContainType',
],
'arrayKeyCannotBeFloat' => [
'code' => '<?php
/**
* @param string[] $arr
*/
function foo(array $arr) : void {
if (!$arr) {
return;
}
foreach ($arr as $i => $_) {}
if ($i === 4.0) {}
}',
'error_message' => 'TypeDoesNotContainType',
],
'arrayKeyCannotBeObject' => [
'code' => '<?php
/**
* @param string[] $arr
*/
function foo(array $arr) : void {
if (!$arr) {
return;
}
foreach ($arr as $i => $_) {}
if ($i === new stdClass) {}
}',
'error_message' => 'TypeDoesNotContainType',
],
2019-03-23 19:27:54 +01:00
'forbidNegativeStringOffsetOutOfRange' => [
'code' => '<?php
$a = "hello";
echo $a[-6];',
'error_message' => 'InvalidArrayOffset',
],
'emptyStringAccess' => [
'code' => '<?php
$a = "";
echo $a[0];',
'error_message' => 'InvalidArrayOffset',
],
'recogniseBadVar' => [
'code' => '<?php
/** @psalm-suppress MixedAssignment */
$array = $_GET["foo"] ?? [];
$array[$a] = "b";',
'error_message' => 'UndefinedGlobalVariable',
],
'unsetListElementShouldChangeToArray' => [
'code' => '<?php
/**
* @param list<string> $arr
* @return list<string>
*/
function takesList(array $arr) : array {
unset($arr[0]);
return $arr;
}',
'error_message' => 'LessSpecificReturnStatement',
],
'simpleXmlArrayFetchResultCannotEqualString' => [
'code' => '<?php
function foo(SimpleXMLElement $s) : void {
$b = $s["a"];
if ($b === "hello" || $b === "1") {}
}',
'error_message' => 'TypeDoesNotContainType',
],
'undefinedTKeyedArrayOffset' => [
'code' => '<?php
class Example {
/**
* @param array{a: string, b: int} $context
*/
function foo(array $context): void {
$context["c"];
}
}',
2022-12-18 17:15:15 +01:00
'error_message' => 'InvalidArrayOffset',
],
'destructureNullable' => [
'code' => '<?php
/**
* @return null|array
*/
function maybeReturnArray(): ?array {
return rand(0, 1) ? null : ["key" => 1];
}
["key" => $a] = maybeReturnArray();',
'error_message' => 'PossiblyNullArrayAccess',
],
'destructureTuple' => [
'code' => '<?php
/**
* @return array{int, int}
*/
function size(): array {
return [10, 20];
}
[$width, $height, $depth] = size();',
'error_message' => 'InvalidArrayOffset',
],
'negativeListAccess' => [
'code' => '<?php
class HelloWorld
{
public function sayHello(): void
{
$a = explode("/", "a/b/c");
$x = $a[-3];
echo $x;
}
}',
2022-12-18 17:15:15 +01:00
'error_message' => 'InvalidArrayOffset',
],
'arrayOpenByDefault' => [
'code' => '<?php
/**
* @param array{a: float, b: float} $params
*/
function avg(array $params): void {
takesArrayOfFloats($params);
}
/**
* @param array<array-key, float> $arr
*/
function takesArrayOfFloats(array $arr): void {
foreach ($arr as $a) {
echo $a;
}
}
avg(["a" => 0.5, "b" => 1.5, "c" => new Exception()]);',
2022-12-18 17:15:15 +01:00
'error_message' => 'InvalidArgument',
],
2024-01-12 23:37:45 +01:00
'possiblyUndefinedArrayOffsetKeyedArray' => [
'code' => '<?php
$d = [];
if (!rand(0,1)) {
$d[0] = "a";
}
$x = $d[0];
// should not report TypeDoesNotContainNull
if ($x === null) {}',
'error_message' => 'PossiblyUndefinedArrayOffset',
],
];
}
2016-12-12 05:41:11 +01:00
}