danog/psalm
1
0
Fork 0
mirror of https://github.com/danog/psalm.git synced 2024-12-15 10:57:08 +01:00
Code Issues Projects Releases Wiki Activity
599ba0e755
psalm/tests/AssertAnnotationTest.php

2394 lines
81 KiB
PHP
Raw Normal View History

Break up assert tests
2019-10-01 22:51:23 +02:00
<?php
Allow assertions on static class properties (#4833) * Minimal implementation for assertions on static properties * Added inheritance tests * Add support for `ClassName::$var` * Import strpos() to keep phpcs happy * Add support for conditional assertions on static properties
2020-12-21 18:05:44 +01:00
Break up assert tests
2019-10-01 22:51:23 +02:00
namespace Psalm\Tests;
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
use Psalm\Config;
use Psalm\Context;
use Psalm\Exception\CodeException;
Handle some partials
2021-12-04 21:55:53 +01:00
use Psalm\Tests\Traits\InvalidCodeAnalysisTestTrait;
use Psalm\Tests\Traits\ValidCodeAnalysisTestTrait;
Fix windows tests (#4040) * Fix windows tests by not mangling the expectations * Use platform-dependent directory separator in expected messages * fix CS
2020-08-22 16:00:36 +02:00
use const DIRECTORY_SEPARATOR;
Break up assert tests
2019-10-01 22:51:23 +02:00
class AssertAnnotationTest extends TestCase
{
Handle some partials
2021-12-04 21:55:53 +01:00
use ValidCodeAnalysisTestTrait;
use InvalidCodeAnalysisTestTrait;
Break up assert tests
2019-10-01 22:51:23 +02:00
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
public function testDontForgetAssertionAfterMutationFreeCall(): void
{
Config::getInstance()->remember_property_assignments_after_call = false;
$this->addFile(
'somefile.php',
'<?php
class Foo
{
public ?string $bar = null;
/** @psalm-mutation-free */
public function mutationFree(): void {}
}
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
}
$foo = new Foo();
if (assertBarNotNull($foo)) {
$foo->mutationFree();
requiresString($foo->bar);
}
function requiresString(string $str): void {}
'
);
$this->analyzeFile('somefile.php', new Context());
}
public function testForgetAssertionAfterNonMutationFreeCall(): void
{
$this->expectExceptionMessage('PossiblyNullArgument');
$this->expectException(CodeException::class);
Config::getInstance()->remember_property_assignments_after_call = false;
$this->addFile(
'somefile.php',
'<?php
class Foo
{
public ?string $bar = null;
public function nonMutationFree(): void {}
}
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
}
$foo = new Foo();
if (assertBarNotNull($foo)) {
$foo->nonMutationFree();
requiresString($foo->bar);
}
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
function requiresString(string $_str): void {}
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
'
);
$this->analyzeFile('somefile.php', new Context());
}
Break up assert tests
2019-10-01 22:51:23 +02:00
/**
* @return iterable<string,array{string,assertions?:array<string,string>,error_levels?:string[]}>
*/
More return types (#4173) * add native return types * redundant phpdoc
2020-09-12 17:24:05 +02:00
public function providerValidCodeParse(): iterable
Break up assert tests
2019-10-01 22:51:23 +02:00
{
return [
'implictAssertInstanceOfB' => [
'<?php
namespace Bar;
class A {}
class B extends A {
public function foo(): void {}
}
function assertInstanceOfB(A $var): void {
if (!$var instanceof B) {
throw new \Exception();
}
}
function takesA(A $a): void {
assertInstanceOfB($a);
$a->foo();
}',
],
Fix #2578 - improve inference of functions beginning with assert
2020-01-09 21:45:17 +01:00
'implicitAssertEqualsNull' => [
'<?php
function takesInt(int $int): void { echo $int; }
function getIntOrNull(): ?int {
return rand(0,1) === 0 ? null : 1;
}
/** @param mixed $value */
function assertNotNull($value): void {
if (null === $value) {
throw new Exception();
}
}
$value = getIntOrNull();
assertNotNull($value);
takesInt($value);',
],
Break up assert tests
2019-10-01 22:51:23 +02:00
'dropInReplacementForAssert' => [
'<?php
namespace Bar;
/**
* @param mixed $_b
* @psalm-assert !falsy $_b
*/
function myAssert($_b) : void {
if (!$_b) {
throw new \Exception("bad");
}
}
function bar(?string $s) : string {
myAssert($s !== null);
return $s;
}',
],
Fix #3858 - support @psalm-assert falsy for abort_if expressions
2020-07-21 18:55:11 +02:00
'dropInReplacementForAntiAssert' => [
'<?php
/**
* @param mixed $foo
* @psalm-assert falsy $foo
*/
function abort_if($foo): void
{
if ($foo) {
throw new \RuntimeException();
}
}
/**
* @param string|null $foo
*/
function removeNullable($foo): string
{
abort_if(is_null($foo));
return $foo;
}'
],
Break up assert tests
2019-10-01 22:51:23 +02:00
'sortOfReplacementForAssert' => [
'<?php
namespace Bar;
/**
* @param mixed $_b
* @psalm-assert true $_b
*/
function myAssert($_b) : void {
if ($_b !== true) {
throw new \Exception("bad");
}
}
function bar(?string $s) : string {
myAssert($s !== null);
return $s;
}',
],
'implictAssertInstanceOfInterface' => [
'<?php
namespace Bar;
class A {
public function bar() : void {}
}
interface I {
public function foo(): void;
}
class B extends A implements I {
public function foo(): void {}
}
function assertInstanceOfI(A $var): void {
if (!$var instanceof I) {
throw new \Exception();
}
}
function takesA(A $a): void {
assertInstanceOfI($a);
$a->bar();
$a->foo();
}',
],
'implicitAssertInstanceOfMultipleInterfaces' => [
'<?php
namespace Bar;
class A {
public function bar() : void {}
}
interface I1 {
public function foo1(): void;
}
interface I2 {
public function foo2(): void;
}
class B extends A implements I1, I2 {
public function foo1(): void {}
public function foo2(): void {}
}
function assertInstanceOfInterfaces(A $var): void {
if (!$var instanceof I1 || !$var instanceof I2) {
throw new \Exception();
}
}
function takesA(A $a): void {
assertInstanceOfInterfaces($a);
$a->bar();
$a->foo1();
}',
],
'implicitAssertInstanceOfBInClassMethod' => [
'<?php
namespace Bar;
class A {}
class B extends A {
public function foo(): void {}
}
class C {
private function assertInstanceOfB(A $var): void {
if (!$var instanceof B) {
throw new \Exception();
}
}
private function takesA(A $a): void {
$this->assertInstanceOfB($a);
$a->foo();
}
}',
],
'implicitAssertPropertyNotNull' => [
'<?php
namespace Bar;
class A {
public function foo(): void {}
}
class B {
/** @var A|null */
public $a;
private function assertNotNullProperty(): void {
if (!$this->a) {
throw new \Exception();
}
}
public function takesA(A $a): void {
$this->assertNotNullProperty();
$a->foo();
}
}',
],
'implicitAssertWithoutRedundantCondition' => [
'<?php
namespace Bar;
/**
* @param mixed $data
* @throws \Exception
*/
function assertIsLongString($data): void {
fix test
2021-09-16 23:57:20 +02:00
if (!\is_string($data)) {
Break up assert tests
2019-10-01 22:51:23 +02:00
throw new \Exception;
}
if (strlen($data) < 100) {
throw new \Exception;
}
}
/**
* @throws \Exception
*/
function f(string $s): void {
assertIsLongString($s);
}',
],
'assertInstanceOfBAnnotation' => [
'<?php
namespace Bar;
class A {}
class B extends A {
public function foo(): void {}
}
/** @psalm-assert B $var */
function myAssertInstanceOfB(A $var): void {
if (!$var instanceof B) {
throw new \Exception();
}
}
function takesA(A $a): void {
myAssertInstanceOfB($a);
$a->foo();
}',
],
'assertIfTrueAnnotation' => [
'<?php
namespace Bar;
/** @psalm-assert-if-true string $myVar */
function isValidString(?string $myVar) : bool {
return $myVar !== null && $myVar[0] === "a";
}
$myString = rand(0, 1) ? "abacus" : null;
if (isValidString($myString)) {
echo "Ma chaine " . $myString;
}',
],
'assertIfFalseAnnotation' => [
'<?php
namespace Bar;
/** @psalm-assert-if-false string $myVar */
function isInvalidString(?string $myVar) : bool {
return $myVar === null || $myVar[0] !== "a";
}
$myString = rand(0, 1) ? "abacus" : null;
if (isInvalidString($myString)) {
// do something
} else {
echo "Ma chaine " . $myString;
}',
],
'assertServerVar' => [
'<?php
namespace Bar;
/**
* @psalm-assert-if-true string $a
* @param mixed $a
*/
function my_is_string($a) : bool
{
return is_string($a);
}
if (my_is_string($_SERVER["abc"])) {
$i = substr($_SERVER["abc"], 1, 2);
}',
],
'dontBleedBadAssertVarIntoContext' => [
'<?php
namespace Bar;
class A {
public function foo() : bool {
return (bool) rand(0, 1);
}
public function bar() : bool {
return (bool) rand(0, 1);
}
}
/**
* Asserts that a condition is false.
*
* @param bool $condition
* @param string $message
*
* @psalm-assert false $actual
*/
function assertFalse($condition, $message = "") : void {}
function takesA(A $a) : void {
assertFalse($a->foo());
assertFalse($a->bar());
}',
],
'assertAllStrings' => [
'<?php
/**
* @psalm-assert iterable<mixed,string> $i
*
* @param iterable<mixed,mixed> $i
*/
function assertAllStrings(iterable $i): void {
/** @psalm-suppress MixedAssignment */
foreach ($i as $s) {
if (!is_string($s)) {
throw new \UnexpectedValueException("");
}
}
}
function getArray(): array {
return [];
}
function getIterable(): iterable {
return [];
}
$array = getArray();
assertAllStrings($array);
$iterable = getIterable();
assertAllStrings($iterable);',
[
'$array' => 'array<array-key, string>',
'$iterable' => 'iterable<mixed, string>',
],
],
'assertStaticMethodIfFalse' => [
'<?php
class StringUtility {
/**
* @psalm-assert-if-false !null $yStr
*/
public static function isNull(?string $yStr): bool {
if ($yStr === null) {
return true;
}
return false;
}
}
function test(?string $in) : void {
$str = "test";
if(!StringUtility::isNull($in)) {
$str .= $in;
}
}',
],
'assertStaticMethodIfTrue' => [
'<?php
class StringUtility {
/**
* @psalm-assert-if-true !null $yStr
*/
public static function isNotNull(?string $yStr): bool {
if ($yStr === null) {
return true;
}
return false;
}
}
function test(?string $in) : void {
$str = "test";
if(StringUtility::isNotNull($in)) {
$str .= $in;
}
}',
],
'assertUnion' => [
'<?php
class Foo{
public function bar() : void {}
}
/**
* @param mixed $b
* @psalm-assert int|Foo $b
*/
function assertIntOrFoo($b) : void {
if (!is_int($b) && !(is_object($b) && $b instanceof Foo)) {
throw new \Exception("bad");
}
}
/** @psalm-suppress MixedAssignment */
$a = $_GET["a"];
assertIntOrFoo($a);
if (!is_int($a)) $a->bar();',
],
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
'assertThisType' => [
'<?php
class Type {
/**
* @psalm-assert FooType $this
*/
public function isFoo() : bool {
if (!$this instanceof FooType) {
throw new \Exception();
}
Fix #3095 - allow intersection of arrays after assertions
2020-04-10 05:02:28 +02:00
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
return true;
}
}
class FooType extends Type {
public function bar(): void {}
}
function takesType(Type $t) : void {
$t->isFoo();
$t->bar();
}'
],
Break up assert tests
2019-10-01 22:51:23 +02:00
'assertThisTypeIfTrue' => [
'<?php
class Type {
/**
* @psalm-assert-if-true FooType $this
*/
public function isFoo() : bool {
return $this instanceof FooType;
}
}
class FooType extends Type {
public function bar(): void {}
}
function takesType(Type $t) : void {
if ($t->isFoo()) {
$t->bar();
}
Use better system for storing inferred types and assertions
2019-11-25 17:44:54 +01:00
}'
],
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
'assertThisTypeCombined' => [
'<?php
class Type {
/**
* @psalm-assert FooType $this
*/
public function assertFoo() : void {
if (!$this instanceof FooType) {
throw new \Exception();
}
}
Fix #3095 - allow intersection of arrays after assertions
2020-04-10 05:02:28 +02:00
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
/**
* @psalm-assert BarType $this
*/
public function assertBar() : void {
if (!$this instanceof BarType) {
throw new \Exception();
}
}
}
interface FooType {
public function foo(): void;
}
interface BarType {
public function bar(): void;
}
function takesType(Type $t) : void {
$t->assertFoo();
$t->assertBar();
$t->foo();
$t->bar();
}'
],
Fix $assertion_var_id calculation in method calls (#3115)
2020-04-10 05:03:53 +02:00
'assertThisTypeCombinedInsideMethod' => [
'<?php
class Type {
/**
* @psalm-assert FooType $this
*/
public function assertFoo() : void {
if (!$this instanceof FooType) {
throw new \Exception();
}
}
Fix #3443 - add InvalidDocblock issue for @psalm-assert Foo|!Bar
2020-05-24 04:52:21 +02:00
Fix $assertion_var_id calculation in method calls (#3115)
2020-04-10 05:03:53 +02:00
/**
* @psalm-assert BarType $this
*/
public function assertBar() : void {
if (!$this instanceof BarType) {
throw new \Exception();
}
}
Fix #3443 - add InvalidDocblock issue for @psalm-assert Foo|!Bar
2020-05-24 04:52:21 +02:00
Fix $assertion_var_id calculation in method calls (#3115)
2020-04-10 05:03:53 +02:00
function takesType(Type $t) : void {
$t->assertFoo();
$t->assertBar();
$t->foo();
$t->bar();
}
}
interface FooType {
public function foo(): void;
}
interface BarType {
public function bar(): void;
}
'
],
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
'assertThisTypeSimpleCombined' => [
'<?php
class Type {
/**
* @psalm-assert FooType $this
*/
public function assertFoo() : void {
if (!$this instanceof FooType) {
throw new \Exception();
}
return;
}
Fix #3095 - allow intersection of arrays after assertions
2020-04-10 05:02:28 +02:00
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
/**
* @psalm-assert BarType $this
*/
public function assertBar() : void {
if (!$this instanceof BarType) {
throw new \Exception();
}
return;
}
}
interface FooType {
public function foo(): void;
}
interface BarType {
public function bar(): void;
}
/** @param Type&FooType $t */
function takesType(Type $t) : void {
$t->assertBar();
$t->foo();
$t->bar();
}'
],
'assertThisTypeIfTrueCombined' => [
'<?php
class Type {
/**
* @psalm-assert-if-true FooType $this
*/
public function assertFoo() : bool {
return $this instanceof FooType;
}
Fix #3095 - allow intersection of arrays after assertions
2020-04-10 05:02:28 +02:00
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
/**
* @psalm-assert-if-true BarType $this
*/
public function assertBar() : bool {
return $this instanceof BarType;
}
}
interface FooType {
public function foo(): void;
}
interface BarType {
public function bar(): void;
}
function takesType(Type $t) : void {
if ($t->assertFoo() && $t->assertBar()) {
$t->foo();
$t->bar();
}
}'
],
'assertThisTypeSimpleAndIfTrueCombined' => [
'<?php
class Type {
/**
* @psalm-assert BarType $this
* @psalm-assert-if-true FooType $this
*/
public function isFoo() : bool {
if (!$this instanceof BarType) {
throw new \Exception();
}
return $this instanceof FooType;
}
}
interface FooType {
public function foo(): void;
}
interface BarType {
public function bar(): void;
}
function takesType(Type $t) : void {
if ($t->isFoo()) {
$t->foo();
}
$t->bar();
}'
],
Use better system for storing inferred types and assertions
2019-11-25 17:44:54 +01:00
'assertThisTypeSwitchTrue' => [
'<?php
class Type {
/**
* @psalm-assert-if-true FooType $this
*/
public function isFoo() : bool {
return $this instanceof FooType;
}
}
class FooType extends Type {
public function bar(): void {}
}
function takesType(Type $t) : void {
Break up assert tests
2019-10-01 22:51:23 +02:00
switch (true) {
case $t->isFoo():
Use better system for storing inferred types and assertions
2019-11-25 17:44:54 +01:00
$t->bar();
Break up assert tests
2019-10-01 22:51:23 +02:00
}
}'
],
'assertNotArray' => [
'<?php
/**
* @param mixed $value
* @psalm-assert !array $value
*/
function myAssertNotArray($value) : void {}
/**
* @param mixed $value
* @psalm-assert !iterable $value
*/
function myAssertNotIterable($value) : void {}
/**
* @param int|array $v
*/
function takesIntOrArray($v) : int {
myAssertNotArray($v);
return $v;
}
/**
* @param int|iterable $v
*/
function takesIntOrIterable($v) : int {
myAssertNotIterable($v);
return $v;
}'
],
'assertIfTrueOnProperty' => [
'<?php
class A {
public function foo() : void {}
}
class B {
private ?A $a = null;
public function bar() : void {
if ($this->assertProperty()) {
$this->a->foo();
}
}
/**
* @psalm-assert-if-true !null $this->a
*/
public function assertProperty() : bool {
return $this->a !== null;
}
}'
],
'assertIfFalseOnProperty' => [
'<?php
class A {
public function foo() : void {}
}
class B {
private ?A $a = null;
public function bar() : void {
if ($this->assertProperty()) {
$this->a->foo();
}
}
/**
* @psalm-assert-if-false null $this->a
*/
public function assertProperty() : bool {
return $this->a !== null;
}
}'
],
'assertIfTrueOnPropertyNegated' => [
'<?php
class A {
public function foo() : void {}
}
class B {
private ?A $a = null;
public function bar() : void {
if (!$this->assertProperty()) {
$this->a->foo();
}
}
/**
* @psalm-assert-if-true null $this->a
*/
public function assertProperty() : bool {
return $this->a !== null;
}
}'
],
'assertIfFalseOnPropertyNegated' => [
'<?php
class A {
public function foo() : void {}
}
class B {
private ?A $a = null;
public function bar() : void {
if (!$this->assertProperty()) {
$this->a->foo();
}
}
/**
* @psalm-assert-if-false !null $this->a
*/
public function assertProperty() : bool {
return $this->a !== null;
}
}'
],
'assertPropertyVisibleOutside' => [
'<?php
class A {
public ?int $x = null;
public function maybeAssignX() : void {
if (rand(0, 0) == 0) {
$this->x = 0;
}
}
/**
* @psalm-assert !null $this->x
*/
public function assertProperty() : void {
if (is_null($this->x)) {
throw new RuntimeException();
}
}
}
$a = new A();
$a->maybeAssignX();
$a->assertProperty();
echo (2 * $a->x);',
],
'parseAssertion' => [
'<?php
/**
* @psalm-assert array<string, string[]> $data
* @param mixed $data
*/
function isArrayOfStrings($data): void {}
function foo(array $arr) : void {
isArrayOfStrings($arr);
foreach ($arr as $a) {
foreach ($a as $b) {
echo $b;
}
}
}'
],
'noExceptionOnShortArrayAssertion' => [
'<?php
/**
* @param mixed[] $a
*/
function one(array $a): void {
isInts($a);
}
/**
* @psalm-assert int[] $value
* @param mixed $value
*/
function isInts($value): void {}',
],
Support assertions on lists
2019-10-10 16:57:43 +02:00
'simpleArrayAssertion' => [
'<?php
/**
* @psalm-assert array $data
* @param mixed $data
*/
function isArray($data): void {}
/**
* @param iterable<string> $arr
* @return array<string>
*/
function foo(iterable $arr) : array {
isArray($arr);
return $arr;
}'
],
'listAssertion' => [
'<?php
/**
* @psalm-assert list $data
* @param mixed $data
*/
function isList($data): void {}
/**
* @param array<string> $arr
* @return list<string>
*/
function foo(array $arr) : array {
isList($arr);
return $arr;
}'
],
Fix #2277 - scan psalm-assert types always
2019-10-25 23:39:33 +02:00
'scanAssertionTypes' => [
'<?php
/**
* @param mixed $_p
* @psalm-assert-if-true Exception $_p
* @psalm-assert-if-false Error $_p
* @psalm-assert Throwable $_p
*/
function f($_p): bool {
return true;
}
$q = null;
if (rand(0, 1) && f($q)) {}
if (!f($q)) {}'
],
Refine lists with object-like array types Fixes #2357
2019-11-26 18:22:28 +01:00
'assertDifferentTypeOfArray' => [
'<?php
/**
* @psalm-assert array{0: string, 1: string} $value
* @param mixed $value
*/
function isStringTuple($value): void {
if (!is_array($value)
|| !isset($value[0])
|| !isset($value[1])
|| !is_string($value[0])
|| !is_string($value[1])
) {
throw new \Exception("bad");
}
}
$s = "";
$parts = explode(":", $s, 2);
isStringTuple($parts);
echo $parts[0];
echo $parts[1];'
],
Improve int assertions
2019-12-10 15:44:38 +01:00
'assertStringOrIntOnString' => [
'<?php
/**
* @param mixed $v
* @psalm-assert string|int $v
*/
function assertStringOrInt($v) : void {}
function gimmeAString(?string $v): string {
/** @psalm-suppress TypeDoesNotContainType */
assertStringOrInt($v);
return $v;
}',
],
Fix #2484 - add support for spaces in assert-if-true types
2019-12-19 20:24:26 +01:00
'assertIfTrueWithSpace' => [
'<?php
/**
* @param mixed $data
* @return bool
* @psalm-assert-if-true array{type: string} $data
*/
function isBar($data) {
return isset($data["type"]);
}
/**
* @param mixed $data
* @return string
*/
function doBar($data) {
if (isBar($data)) {
return $data["type"];
}
throw new \Exception();
}'
],
Allow assertions on nested properties
2019-12-30 16:01:31 +01:00
'assertOnNestedProperty' => [
'<?php
/** @psalm-immutable */
class B {
public ?array $arr = null;
public function __construct(?array $arr) {
$this->arr = $arr;
}
}
/** @psalm-immutable */
class A {
public B $b;
public function __construct(B $b) {
$this->b = $b;
}
/** @psalm-assert-if-true !null $this->b->arr */
public function hasArray() : bool {
return $this->b->arr !== null;
}
}
function foo(A $a) : void {
if ($a->hasArray()) {
echo count($a->b->arr);
}
}'
],
'assertOnNestedMethod' => [
'<?php
/** @psalm-immutable */
class B {
private ?array $arr = null;
public function __construct(?array $arr) {
$this->arr = $arr;
}
public function getArray() : ?array {
return $this->arr;
}
}
/** @psalm-immutable */
class A {
public B $b;
public function __construct(B $b) {
$this->b = $b;
}
/** @psalm-assert-if-true !null $this->b->getarray() */
public function hasArray() : bool {
return $this->b->getArray() !== null;
}
}
function foo(A $a) : void {
if ($a->hasArray()) {
echo count($a->b->getArray());
}
}'
],
Improve assertions support a bit more
2019-12-30 16:48:50 +01:00
'assertOnThisMethod' => [
'<?php
/** @psalm-immutable */
class A {
private ?array $arr = null;
public function __construct(?array $arr) {
$this->arr = $arr;
}
/** @psalm-assert-if-true !null $this->getarray() */
public function hasArray() : bool {
return $this->arr !== null;
}
public function getArray() : ?array {
return $this->arr;
}
}
function foo(A $a) : void {
if (!$a->hasArray()) {
return;
}
echo count($a->getArray());
}'
],
Fix #2409 - use more robust assertion parsing
2019-12-31 15:10:14 +01:00
'preventErrorWhenAssertingOnArrayUnion' => [
'<?php
/**
* @psalm-assert array<string,string|object> $data
*/
function validate(array $data): void {}'
],
Fix #2636 - allow non-empty-list in assert annotation
2020-01-17 15:06:29 +01:00
'nonEmptyList' => [
'<?php
/**
* @psalm-assert non-empty-list $array
*
* @param mixed $array
*/
function isNonEmptyList($array): void {}
/**
* @psalm-param mixed $value
*
* @psalm-return non-empty-list<mixed>
*/
Allow assertions of non-empty lists on typed lists Fixes #3906
2020-07-30 00:10:43 +02:00
function consume1($value): array {
Fix #2636 - allow non-empty-list in assert annotation
2020-01-17 15:06:29 +01:00
isNonEmptyList($value);
return $value;
Allow assertions of non-empty lists on typed lists Fixes #3906
2020-07-30 00:10:43 +02:00
}
/**
* @psalm-param list<string> $values
*/
function consume2(array $values): void {
isNonEmptyList($values);
foreach ($values as $str) {}
echo $str;
}'
],
'nonEmptyListOfStrings' => [
'<?php
/**
* @psalm-assert non-empty-list<string> $array
*
* @param mixed $array
*/
function isNonEmptyListOfStrings($array): void {}
/**
* @psalm-param list<string> $values
*/
function consume2(array $values): void {
isNonEmptyListOfStrings($values);
foreach ($values as $str) {}
echo $str;
Fix #2636 - allow non-empty-list in assert annotation
2020-01-17 15:06:29 +01:00
}'
],
fclose should treat resource as passed-by-reference
2020-01-17 19:12:00 +01:00
'assertResource' => [
'<?php
/**
* @param mixed $foo
* @psalm-assert resource $foo
*/
function assertResource($foo) : void {
if (!is_resource($foo)) {
throw new \Exception("bad");
}
}
/**
* @param mixed $value
*
* @return resource
*/
function consume($value)
{
assertResource($value);
return $value;
}'
],
Fix deprecated call
2020-04-03 20:56:11 +02:00
'parseLongAssertion' => [
'<?php
/**
* @psalm-assert array{
* extensions: array<string, array{
* version?: string,
* type?: "bundled"|"pecl",
* require?: list<string>,
* env?: array<string, array{
* deps?: list<string>,
* buildDeps?: list<string>,
* configure?: string
* }>
* }>
* } $data
*
* @param mixed $data
*/
function assertStructure($data): void {}'
],
Fix #3095 - allow intersection of arrays after assertions
2020-04-10 05:02:28 +02:00
'intersectArraysAfterAssertion' => [
'<?php
/**
* @psalm-assert array{foo: string} $v
*/
function hasFoo(array $v): void {}
/**
* @psalm-assert array{bar: int} $v
*/
function hasBar(array $v): void {}
function process(array $data): void {
hasFoo($data);
hasBar($data);
echo sprintf("%s %d", $data["foo"], $data["bar"]);
}'
],
Allow lists to have their types refined Fixes #3605
2020-06-18 16:01:10 +02:00
'assertListIsIterableOfStrings' => [
'<?php
/**
* @psalm-assert iterable<string> $value
*
* @param mixed $value
*
* @throws InvalidArgumentException
*/
function allString($value): void {}
function takesAnArray(array $a): void {
$keys = array_keys($a);
allString($keys);
}',
],
'assertListIsListOfStrings' => [
'<?php
/**
* @psalm-assert list<string> $value
*
* @param mixed $value
*
* @throws InvalidArgumentException
*/
function allString($value): void {}
function takesAnArray(array $a): void {
$keys = array_keys($a);
allString($keys);
}',
],
Fix #3811 - allow more complex negations inside boolean expressions
2020-07-14 03:31:58 +02:00
'multipleAssertIfTrue' => [
'<?php
/**
* @param mixed $a
* @param mixed $b
* @psalm-assert-if-true string $a
* @psalm-assert-if-true string $b
*/
function assertAandBAreStrings($a, $b): bool {
if (!is_string($a)) { return false;}
if (!is_string($b)) { return false;}
return true;
}
/**
* @param mixed $a
* @param mixed $b
*/
function test($a, $b): string {
if (!assertAandBAreStrings($a, $b)) {
throw new \Exception();
}
return substr($a, 0, 1) . substr($b, 0, 1);
}'
],
qa: re-enable skipped test for class constant assertions Signed-off-by: Maximilian Bösing <2189546+boesing@users.noreply.github.com>
2021-11-15 18:49:51 +01:00
'convertConstStringType' => [
Fix #3741 - detect scalar class constants in if-true assertions
2020-08-12 23:03:41 +02:00
'<?php
class A {
Ensure getId() output can always be parsed as a type Ref #5105
2021-01-26 05:41:42 +01:00
const T1 = 1;
Fix #3741 - detect scalar class constants in if-true assertions
2020-08-12 23:03:41 +02:00
const T2 = 2;
/**
* @param self::T* $t
*/
public static function bar(int $t):void {}
/**
* @psalm-assert-if-true self::T* $t
*/
public static function isValid(int $t): bool {
return in_array($t, [self::T1, self::T2], true);
}
}
function takesA(int $a) : void {
if (A::isValid($a)) {
A::bar($a);
}
}'
],
Fix #4414 - allow multiple @psalm-assert-if-true on same var
2020-10-25 15:49:39 +01:00
'multipleAssertIfTrueOnSameVariable' => [
'<?php
class A {}
function foo(string|null|A $a) : A {
if (isComputed($a)) {
return $a;
}
throw new Exception("bad");
}
/**
* @psalm-assert-if-true !null $value
* @psalm-assert-if-true !string $value
*/
function isComputed(mixed $value): bool {
return $value !== null && !is_string($value);
}',
[],
[],
'8.0'
],
Allow assertions on static class properties (#4833) * Minimal implementation for assertions on static properties * Added inheritance tests * Add support for `ClassName::$var` * Import strpos() to keep phpcs happy * Add support for conditional assertions on static properties
2020-12-21 18:05:44 +01:00
'assertStaticSelf' => [
'<?php
final class C {
/** @var null|int */
private static $q = null;
/** @psalm-assert int self::$q */
private static function prefillQ(): void {
self::$q = 123;
}
public static function getQ(): int {
self::prefillQ();
return self::$q;
}
}
?>'
],
'assertIfTrueStaticSelf' => [
'<?php
final class C {
/** @var null|int */
private static $q = null;
/** @psalm-assert-if-true int self::$q */
private static function prefillQ(): bool {
if (rand(0,1)) {
self::$q = 123;
return true;
}
return false;
}
public static function getQ(): int {
if (self::prefillQ()) {
return self::$q;
}
return -1;
}
}
?>'
],
'assertIfFalseStaticSelf' => [
'<?php
final class C {
/** @var null|int */
private static $q = null;
/** @psalm-assert-if-false int self::$q */
private static function prefillQ(): bool {
if (rand(0,1)) {
self::$q = 123;
return false;
}
return true;
}
public static function getQ(): int {
if (self::prefillQ()) {
return -1;
}
return self::$q;
}
}
?>'
],
'assertStaticByInheritedMethod' => [
'<?php
class A {
/** @var null|int */
protected static $q = null;
/** @psalm-assert int self::$q */
protected static function prefillQ(): void {
self::$q = 123;
}
}
class B extends A {
public static function getQ(): int {
self::prefillQ();
return self::$q;
}
}
?>'
],
'assertInheritedStatic' => [
'<?php
class A {
/** @var null|int */
protected static $q = null;
}
class B extends A {
/** @psalm-assert int self::$q */
protected static function prefillQ(): void {
self::$q = 123;
}
public static function getQ(): int {
self::prefillQ();
return self::$q;
}
}
?>'
],
'assertStaticOnUnrelatedClass' => [
'<?php
class A {
/** @var null|int */
public static $q = null;
}
class B {
/** @psalm-assert int A::$q */
private static function prefillQ(): void {
A::$q = 123;
}
public static function getQ(): int {
self::prefillQ();
return A::$q;
}
}
?>'
],
Fix #5025 - prevent crash in assert function during reflection
2021-01-17 18:08:19 +01:00
'implicitComplexAssertionNoCrash' => [
'<?php
class Foo {
private string $status = "";
public function assertValidStatusTransition(string $status): void
{
if (
("canceled" === $this->status && "complete" === $status)
|| ("canceled" === $this->status && "pending" === $status)
|| ("complete" === $this->status && "canceled" === $status)
|| ("complete" === $this->status && "pending" === $status)
) {
throw new \LogicException();
}
}
}'
],
Fix #5310 - allow iterable coercion from generic object
2021-03-03 06:13:00 +01:00
'assertArrayIteratorIsIterableOfStrings' => [
'<?php
/**
* @psalm-assert iterable<string> $value
* @param mixed $value
*
* @return void
*/
function assertAllString($value) : void {
throw new \Exception(\var_export($value, true));
}
/**
* @param ArrayIterator<string, mixed> $value
*
* @return ArrayIterator<string, string>
*/
function preserveContainerAllArrayIterator($value) {
assertAllString($value);
return $value;
}'
],
Fix #5258 - allow ReflectionParameeter::hasType() to inform getType() return
2021-03-06 22:54:23 +01:00
'implicitReflectionParameterAssertion' => [
'<?php
$method = new ReflectionMethod(stdClass::class);
$parameters = $method->getParameters();
foreach ($parameters as $parameter) {
if ($parameter->hasType()) {
$parameter->getType()->__toString();
}
}',
],
Stubbed RelfectionNamedType
2021-10-14 00:09:52 +02:00
'reflectionNameTypeClassStringIfNotBuiltin' => [
'<?php
Made the test marked 7.4
2021-10-14 11:05:40 +02:00
/** @return class-string|null */
Stubbed RelfectionNamedType
2021-10-14 00:09:52 +02:00
function getPropertyType(\ReflectionProperty $reflectionItem): ?string {
$type = $reflectionItem->getType();
return ($type instanceof \ReflectionNamedType) && !$type->isBuiltin() ? $type->getName() : null;
Made the test marked 7.4
2021-10-14 11:05:40 +02:00
}',
[],
[],
'7.4',
Stubbed RelfectionNamedType
2021-10-14 00:09:52 +02:00
],
Fix #5258 - allow ReflectionParameeter::hasType() to inform getType() return
2021-03-06 22:54:23 +01:00
'withHasTypeCall' => [
'<?php
/**
* @psalm-immutable
*/
class Param {
/**
* @psalm-assert-if-true ReflectionType $this->getType()
*/
public function hasType() : bool {
return true;
}
public function getType() : ?ReflectionType {
return null;
}
}
function takesParam(Param $p) : void {
if ($p->hasType()) {
echo $p->getType()->__toString();
}
}',
],
Fix #5406 - track more changes to assertion type
2021-03-16 21:33:09 +01:00
'assertTemplatedIterable' => [
'<?php
class Foo{}
/**
* @param array<Foo> $foos
* @return array<Foo>
*/
function foo(array $foos) : array {
allIsInstanceOf($foos, Foo::class);
return $foos;
}
/**
* @template ExpectedType of object
*
* @param mixed $value
* @param class-string<ExpectedType> $class
* @psalm-assert iterable<ExpectedType> $value
*/
function allIsInstanceOf($value, $class): void {}'
],
Add ReflectionProperty::getType() and hasType()
2021-04-06 12:29:30 +02:00
'implicitReflectionPropertyAssertion' => [
'<?php
$class = new ReflectionClass(stdClass::class);
$properties = $class->getProperties();
foreach ($properties as $property) {
if ($property->hasType()) {
$property->getType()->allowsNull();
}
}',
[],
[],
'7.4'
],
Added support of asserting properties of objects out of scope
2021-10-17 10:29:25 +02:00
'onPropertyOfImmutableArgument' => [
'<?php
/** @psalm-immutable */
class Aclass {
public ?string $b;
public function __construct(?string $b) {
$this->b = $b;
}
}
/** @psalm-assert !null $item->b */
function c(\Aclass $item): void {
if (null === $item->b) {
throw new \InvalidArgumentException("");
}
}
/** @var \Aclass $a */
c($a);
echo strlen($a->b);',
],
'inTrueOnPropertyOfImmutableArgument' => [
'<?php
/** @psalm-immutable */
class A {
public ?int $b;
public function __construct(?int $b) {
$this->b = $b;
}
}
/** @psalm-assert-if-true !null $item->b */
function c(A $item): bool {
return null !== $item->b;
}
function check(int $a): void {}
/** @var A $a */
if (c($a)) {
check($a->b);
}',
],
'inFalseOnPropertyOfAImmutableArgument' => [
'<?php
/** @psalm-immutable */
class A {
public ?int $b;
public function __construct(?int $b) {
$this->b = $b;
}
}
/** @psalm-assert-if-false !null $item->b */
function c(A $item): bool {
return null === $item->b;
}
function check(int $a): void {}
/** @var A $a */
if (!c($a)) {
check($a->b);
}',
],
'ifTrueOnNestedPropertyOfArgument' => [
'<?php
class B {
public ?string $c;
public function __construct(?string $c) {
$this->c = $c;
}
}
/** @psalm-immutable */
class Aclass {
public B $b;
public function __construct(B $b) {
$this->b = $b;
}
}
/** @psalm-assert-if-true !null $item->b->c */
function c(\Aclass $item): bool {
return null !== $item->b->c;
}
$a = new \Aclass(new \B(null));
if (c($a)) {
echo strlen($a->b->c);
}',
],
'ifFalseOnNestedPropertyOfArgument' => [
'<?php
class B {
public ?string $c;
public function __construct(?string $c) {
$this->c = $c;
}
}
/** @psalm-immutable */
class Aclass {
public B $b;
public function __construct(B $b) {
$this->b = $b;
}
}
/** @psalm-assert-if-false !null $item->b->c */
function c(\Aclass $item): bool {
return null !== $item->b->c;
}
$a = new \Aclass(new \B(null));
if (!c($a)) {
echo strlen($a->b->c);
}',
],
add test
2021-12-13 23:16:27 +01:00
'assertOnKeyedArrayWithClassStringOffset' => [
'<?php
class A
{
function test(): void
{
$a = [stdClass::class => ""];
/** @var array<class-string, mixed> $b */
$b = [];
$this->assertSame($a, $b);
}
/**
* @template T
* @param T $expected
* @param mixed $actual
* @psalm-assert =T $actual
*/
public function assertSame($expected, $actual): void
{
return;
}
}',
],
escape more special chars in keyed array names that won't be read by the parser
2021-12-26 19:19:47 +01:00
'assertOnKeyedArrayWithSpecialCharsInNames' => [
'<?php
class Foo {
/** @var array<string, int> */
public array $bar;
/**
* @param array<string, int> $bar
*/
public function __construct(array $bar) {
$this->bar = $bar;
}
}
$expected = [
"#[]" => 21,
"<<>>" => 6,
];
$foo = new Foo($expected);
assertSame($expected, $foo->bar);
/**
* @psalm-template ExpectedType
* @psalm-param ExpectedType $expected
fix test
2021-12-26 19:23:30 +01:00
* @psalm-param mixed $actual
escape more special chars in keyed array names that won't be read by the parser
2021-12-26 19:19:47 +01:00
* @psalm-assert =ExpectedType $actual
*/
function assertSame($expected, $actual): void {
if ($expected !== $actual) {
throw new Exception("Expected doesn\'t match actual");
}
}',
],
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
'dontForgetAssertionAfterIrrelevantNonMutationFreeCall' => [
'<?php
class Foo
{
public ?string $bar = null;
public function nonMutationFree(): void {}
}
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
}
$foo = new Foo();
if (assertBarNotNull($foo)) {
$foo->nonMutationFree();
requiresString($foo->bar);
}
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
function requiresString(string $_str): void {}
',
],
'SKIPPED-applyAssertionsToReferences' => [ // See #7254
'<?php
class Foo
{
public ?string $bar = null;
}
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
}
$foo = new Foo();
$bar = &$foo;
if (assertBarNotNull($foo)) {
requiresString($bar->bar);
}
function requiresString(string $_str): void {}
',
],
'SKIPPED-applyAssertionsFromReferences' => [ // See #7254
'<?php
class Foo
{
public ?string $bar = null;
}
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
}
$foo = new Foo();
$bar = &$foo;
if (assertBarNotNull($bar)) {
requiresString($foo->bar);
}
function requiresString(string $_str): void {}
',
],
'SKIPPED-applyAssertionsToReferencesWithConditionalOperator' => [ // See #7254
'<?php
class Foo
{
public ?string $bar = null;
}
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
}
$foo = new Foo();
$bar = &$foo;
requiresString(assertBarNotNull($foo) ? $bar->bar : "bar");
function requiresString(string $_str): void {}
',
],
don't crash when pushing a template to in_array
2022-01-05 22:33:20 +01:00
'assertInArrayWithTemplateDontCrash' => [
'<?php
class A{
/**
* @template T
* @param array<T> $objects
* @return array<T>
*/
private function uniquateObjects(array $objects) : array
{
$uniqueObjects = [];
foreach ($objects as $object) {
if (in_array($object, $uniqueObjects, true)) {
continue;
}
$uniqueObjects[] = $object;
}
fix test
2022-01-05 22:39:13 +01:00
return $uniqueObjects;
don't crash when pushing a template to in_array
2022-01-05 22:33:20 +01:00
}
}
',
],
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
'assertionOnMagicProperty' => [
'<?php
/**
* @property ?string $b
*/
class A {
/** @psalm-mutation-free */
public function __get(string $key) {return "";}
public function __set(string $key, string $value): void {}
}
$a = new A;
/** @psalm-assert-if-true string $arg->b */
function assertString(A $arg): bool {return $arg->b !== null;}
if (assertString($a)) {
requiresString($a->b);
}
function requiresString(string $_str): void {}
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
',
],
fix empty string in keyed array offset
2022-01-05 22:26:35 +01:00
'assertWithEmptyStringOnKeyedArray' => [
'<?php
class A
{
function test(): void
{
$a = ["" => ""];
/** @var array<string, mixed> $b */
$b = [];
$this->assertSame($a, $b);
}
/**
* @template T
* @param T $expected
fix test
2022-01-05 22:36:22 +01:00
* @param mixed $actual
fix empty string in keyed array offset
2022-01-05 22:26:35 +01:00
* @psalm-assert =T $actual
*/
fix test
2022-01-05 22:36:22 +01:00
public function assertSame($expected, $actual): void
fix empty string in keyed array offset
2022-01-05 22:26:35 +01:00
{
return;
}
}
',
],
Break up assert tests
2019-10-01 22:51:23 +02:00
];
}
/**
Fix object-like array keys when combining string and automatic keys (fixes #5427). (#5428) * Fix object-like array keys (fixes #5427). * Fix incorrect return types for tests. * Fix false positive list with literal int key.
2021-03-20 02:44:44 +01:00
* @return iterable<string,array{string,error_message:string,1?:string[],2?:bool,3?:string}>
Break up assert tests
2019-10-01 22:51:23 +02:00
*/
More return types (#4173) * add native return types * redundant phpdoc
2020-09-12 17:24:05 +02:00
public function providerInvalidCodeParse(): iterable
Break up assert tests
2019-10-01 22:51:23 +02:00
{
return [
'assertInstanceOfMultipleInterfaces' => [
'<?php
class A {
public function bar() : void {}
}
interface I1 {
public function foo1(): void;
}
interface I2 {
public function foo2(): void;
}
class B extends A implements I1, I2 {
public function foo1(): void {}
public function foo2(): void {}
}
function assertInstanceOfInterfaces(A $var): void {
if (!$var instanceof I1 && !$var instanceof I2) {
throw new \Exception();
}
}
function takesA(A $a): void {
assertInstanceOfInterfaces($a);
$a->bar();
$a->foo1();
}',
'error_message' => 'UndefinedMethod',
],
'assertIfTrueNoAnnotation' => [
'<?php
function isValidString(?string $myVar) : bool {
return $myVar !== null && $myVar[0] === "a";
}
$myString = rand(0, 1) ? "abacus" : null;
if (isValidString($myString)) {
echo "Ma chaine " . $myString;
}',
'error_message' => 'PossiblyNullOperand',
],
'assertIfFalseNoAnnotation' => [
'<?php
function isInvalidString(?string $myVar) : bool {
return $myVar === null || $myVar[0] !== "a";
}
$myString = rand(0, 1) ? "abacus" : null;
if (isInvalidString($myString)) {
// do something
} else {
echo "Ma chaine " . $myString;
}',
'error_message' => 'PossiblyNullOperand',
],
'assertIfTrueMethodCall' => [
'<?php
class C {
/**
* @param mixed $p
* @psalm-assert-if-true int $p
*/
public function isInt($p): bool {
return is_int($p);
}
/**
* @param mixed $p
*/
public function doWork($p): void {
if ($this->isInt($p)) {
strlen($p);
}
}
}',
'error_message' => 'InvalidScalarArgument',
],
'assertIfStaticTrueMethodCall' => [
'<?php
class C {
/**
* @param mixed $p
* @psalm-assert-if-true int $p
*/
public static function isInt($p): bool {
return is_int($p);
}
/**
* @param mixed $p
*/
public function doWork($p): void {
if ($this->isInt($p)) {
strlen($p);
}
}
}',
'error_message' => 'InvalidScalarArgument',
],
'noFatalForUnknownAssertClass' => [
'<?php
interface Foo {}
class Bar implements Foo {
public function sayHello(): void {
echo "Hello";
}
}
/**
* @param mixed $value
* @param class-string $type
* @psalm-assert SomeUndefinedClass $value
*/
function assertInstanceOf($value, string $type): void {
// some code
}
// Returns concreate implementation of Foo, which in this case is Bar
function getImplementationOfFoo(): Foo {
return new Bar();
}
$bar = getImplementationOfFoo();
assertInstanceOf($bar, Bar::class);
$bar->sayHello();',
'error_message' => 'UndefinedDocblockClass',
],
'assertValueImpossible' => [
'<?php
/**
* @psalm-assert "foo"|"bar"|"foo-bar" $s
*/
function assertFooBar(string $s) : void {
}
$a = "";
assertFooBar($a);',
Allow strings in assert annotation
2020-01-28 05:15:50 +01:00
'error_message' => 'TypeDoesNotContainType',
Break up assert tests
2019-10-01 22:51:23 +02:00
],
'sortOfReplacementForAssert' => [
'<?php
namespace Bar;
/**
* @param mixed $_b
* @psalm-assert true $_b
*/
function myAssert($_b) : void {
if ($_b !== true) {
throw new \Exception("bad");
}
}
function bar(?string $s) : string {
myAssert($s);
return $s;
}',
'error_message' => 'TypeDoesNotContainType',
],
Allow multiple @psalm-assert annotations for a given variable
2019-12-09 23:21:58 +01:00
'assertScalarAndEmpty' => [
'<?php
/**
* @param mixed $value
* @psalm-assert scalar $value
* @psalm-assert !empty $value
*/
function assertScalarNotEmpty($value) : void {}
/** @param scalar $s */
function takesScalar($s) : void {}
/**
* @param mixed $bar
*/
function foo($bar) : void {
assertScalarNotEmpty($bar);
takesScalar($bar);
if ($bar) {}
}',
Allow assertions on static class properties (#4833) * Minimal implementation for assertions on static properties * Added inheritance tests * Add support for `ClassName::$var` * Import strpos() to keep phpcs happy * Add support for conditional assertions on static properties
2020-12-21 18:05:44 +01:00
'error_message' => 'RedundantConditionGivenDocblockType - src'
. DIRECTORY_SEPARATOR . 'somefile.php:19:29',
Allow multiple @psalm-assert annotations for a given variable
2019-12-09 23:21:58 +01:00
],
Allow strings in assert annotation
2020-01-28 05:15:50 +01:00
'assertOneOfStrings' => [
'<?php
/**
* @psalm-assert "a"|"b" $s
*/
function foo(string $s) : void {}
function takesString(string $s) : void {
foo($s);
if ($s === "c") {}
}',
'error_message' => 'DocblockTypeContradiction',
],
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
'assertThisType' => [
'<?php
class Type {
/**
* @psalm-assert FooType $this
*/
public function isFoo() : bool {
if (!$this instanceof FooType) {
throw new \Exception();
}
Fix #3095 - allow intersection of arrays after assertions
2020-04-10 05:02:28 +02:00
Allow plain assertions (@psalm-assert) about $this (fixes #3105) (#3108) * Allow plain assertions (@psalm-assert) about $this (fixes #3105) * Fix multiple assertion combining * Fix multiple assertion combining for $this again * Add test for multiple assertion combining for $this again
2020-04-09 14:15:07 +02:00
return true;
}
}
class FooType extends Type {
public function bar(): void {}
}
function takesType(Type $t) : void {
$t->bar();
$t->isFoo();
}',
'error_message' => 'UndefinedMethod',
],
Fix #3443 - add InvalidDocblock issue for @psalm-assert Foo|!Bar
2020-05-24 04:52:21 +02:00
'invalidUnionAssertion' => [
'<?php
interface I {
/**
* @psalm-assert null|!ExpectedType $value
*/
public static function foo($value);
}',
'error_message' => 'InvalidDocblock',
],
Fix #5049 - assertion of `!empty` on bool makes true
2021-01-19 23:19:47 +01:00
'assertNotEmptyOnBool' => [
'<?php
/**
* @param mixed $value
* @psalm-assert !empty $value
*/
function assertNotEmpty($value) : void {}
function foo(bool $bar) : void {
assertNotEmpty($bar);
if ($bar) {}
}',
'error_message' => 'RedundantConditionGivenDocblockType',
],
Fix #5258 - allow ReflectionParameeter::hasType() to inform getType() return
2021-03-06 22:54:23 +01:00
'withoutHasTypeCall' => [
'<?php
$method = new ReflectionMethod(stdClass::class);
$parameters = $method->getParameters();
foreach ($parameters as $parameter) {
$parameter->getType()->__toString();
}',
'error_message' => 'PossiblyNullReference',
],
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
'forgetAssertionAfterRelevantNonMutationFreeCall' => [
Added support of asserting properties of objects out of scope
2021-10-17 10:29:25 +02:00
'<?php
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
class Foo
{
public ?string $bar = null;
Added support of asserting properties of objects out of scope
2021-10-17 10:29:25 +02:00
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
public function nonMutationFree(): void
{
$this->bar = null;
Added support of asserting properties of objects out of scope
2021-10-17 10:29:25 +02:00
}
}
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
Added support of asserting properties of objects out of scope
2021-10-17 10:29:25 +02:00
}
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
$foo = new Foo();
Added support of asserting properties of objects out of scope
2021-10-17 10:29:25 +02:00
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
if (assertBarNotNull($foo)) {
$foo->nonMutationFree();
requiresString($foo->bar);
Added support of asserting properties of objects out of scope
2021-10-17 10:29:25 +02:00
}
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
function requiresString(string $_str): void {}
Allow assertions on mutable object properties. All of the functionality is already there, we just have to not prevent it.
2021-12-30 21:07:55 +01:00
',
'error_message' => 'PossiblyNullArgument',
Added support of asserting properties of objects out of scope
2021-10-17 10:29:25 +02:00
],
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
'SKIPPED-forgetAssertionAfterRelevantNonMutationFreeCallOnReference' => [ // See #7254
Add failing tests for reference property mutation.
2021-12-30 21:40:43 +01:00
'<?php
class Foo
{
public ?string $bar = null;
public function nonMutationFree(): void
{
$this->bar = null;
}
}
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
}
$foo = new Foo();
$fooRef = &$foo;
if (assertBarNotNull($foo)) {
$fooRef->nonMutationFree();
requiresString($foo->bar);
}
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
function requiresString(string $_str): void {}
Add failing tests for reference property mutation.
2021-12-30 21:40:43 +01:00
',
'error_message' => 'PossiblyNullArgument',
],
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
'SKIPPED-forgetAssertionAfterReferenceModification' => [ // See #7254
Add failing tests for reference property mutation.
2021-12-30 21:40:43 +01:00
'<?php
class Foo
{
public ?string $bar = null;
}
/**
* @psalm-assert-if-true !null $foo->bar
*/
function assertBarNotNull(Foo $foo): bool
{
return $foo->bar !== null;
}
$foo = new Foo();
$barRef = &$foo->bar;
if (assertBarNotNull($foo)) {
$barRef = null;
requiresString($foo->bar);
}
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
function requiresString(string $_str): void {}
Add failing tests for reference property mutation.
2021-12-30 21:40:43 +01:00
',
'error_message' => 'PossiblyNullArgument',
],
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
'assertionOnMagicPropertyWithoutMutationFreeGet' => [
'<?php
/**
* @property ?string $b
*/
class A {
public function __get(string $key) {return "";}
public function __set(string $key, string $value): void {}
}
$a = new A;
/** @psalm-assert-if-true string $arg->b */
function assertString(A $arg): bool {return $arg->b !== null;}
if (assertString($a)) {
requiresString($a->b);
}
function requiresString(string $_str): void {}
',
'error_message' => 'A::__get is not mutation-free',
],
'randomValueFromMagicGetterIsNotMutationFree' => [
'<?php
/**
* @property int<1, 10> $b
*/
class A {
/** @psalm-mutation-free */
public function __get(string $key)
{
if ($key === "b") {
return random_int(1, 10);
}
return null;
}
public function __set(string $key, string $value): void
{
throw new \Exception("Setting not supported!");
}
}
$a = new A;
/** @psalm-assert-if-true =1 $arg->b */
function assertBIsOne(A $arg): bool
{
return $arg->b === 1;
}
if (assertBIsOne($a)) {
takesOne($a->b);
}
/** @param 1 $_arg */
function takesOne(int $_arg): void {}
',
Fix directory separator cross-platform issue.
2021-12-30 23:29:40 +01:00
'error_message' => 'ImpureFunctionCall - src' . DIRECTORY_SEPARATOR . 'somefile.php:10:40',
Skip reference tests, allow assertions on magic properties (fixes #6770).
2021-12-30 23:23:59 +01:00
],
Break up assert tests
2019-10-01 22:51:23 +02:00
];
}
}
Reference in New Issue Copy Permalink