1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-15 02:47:02 +01:00
psalm/tests/MethodCallTest.php

1582 lines
53 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\Context;
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 function class_exists;
2021-06-08 04:55:21 +02:00
use const DIRECTORY_SEPARATOR;
class MethodCallTest extends TestCase
2016-12-12 05:41:11 +01:00
{
2021-12-04 21:55:53 +01:00
use InvalidCodeAnalysisTestTrait;
use ValidCodeAnalysisTestTrait;
public function testExtendDocblockParamType(): void
{
if (class_exists('SoapClient') === false) {
$this->markTestSkipped('Cannot run test, base class "SoapClient" does not exist!');
}
$this->addFile(
'somefile.php',
'<?php
new SoapFault("1", "faultstring", "faultactor");'
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testMethodCallMemoize(): void
2020-06-04 22:07:00 +02:00
{
$this->project_analyzer->getConfig()->memoize_method_calls = true;
$this->addFile(
'somefile.php',
'<?php
class A {
function getFoo() : ?Foo {
return rand(0, 1) ? new Foo : null;
}
}
class Foo {
function getBar() : ?Bar {
return rand(0, 1) ? new Bar : null;
}
}
class Bar {
public function bat() : void {}
};
$a = new A();
if ($a->getFoo()) {
if ($a->getFoo()->getBar()) {
$a->getFoo()->getBar()->bat();
}
}'
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
2020-06-04 22:07:00 +02:00
}
public function testPropertyMethodCallMemoize(): void
{
$this->project_analyzer->getConfig()->memoize_method_calls = true;
$this->addFile(
'somefile.php',
'<?php
class Foo
{
private ?string $bar;
public function __construct(?string $bar) {
$this->bar = $bar;
}
public function getBar(): ?string {
return $this->bar;
}
}
function doSomething(Foo $foo): string {
if ($foo->getBar() !== null){
return $foo->getBar();
}
return "hello";
}'
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testPropertyMethodCallMutationFreeMemoize(): void
{
$this->project_analyzer->getConfig()->memoize_method_calls = true;
$this->addFile(
'somefile.php',
'<?php
class Foo
{
private ?string $bar;
public function __construct(?string $bar) {
$this->bar = $bar;
}
/**
* @psalm-mutation-free
*/
public function getBar(): ?string {
return $this->bar;
}
}
function doSomething(Foo $foo): string {
if ($foo->getBar() !== null){
return $foo->getBar();
}
return "hello";
}'
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testUnchainedMethodCallMemoize(): void
2020-06-04 22:07:00 +02:00
{
$this->project_analyzer->getConfig()->memoize_method_calls = true;
$this->addFile(
'somefile.php',
'<?php
class SomeClass {
private ?int $int;
public function __construct() {
$this->int = 1;
}
final public function getInt(): ?int {
return $this->int;
}
}
function printInt(int $int): void {
echo $int;
}
$obj = new SomeClass();
if ($obj->getInt()) {
printInt($obj->getInt());
}'
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
}
public function testUnchainedMutationFreeMethodCallMemoize(): void
{
$this->project_analyzer->getConfig()->memoize_method_calls = true;
$this->addFile(
'somefile.php',
'<?php
class SomeClass {
private ?int $int;
public function __construct() {
$this->int = 1;
}
/**
* @psalm-mutation-free
*/
2020-06-04 22:07:00 +02:00
public function getInt(): ?int {
return $this->int;
}
}
function printInt(int $int): void {
echo $int;
}
$obj = new SomeClass();
if ($obj->getInt()) {
printInt($obj->getInt());
}'
);
2021-12-03 20:11:20 +01:00
$this->analyzeFile('somefile.php', new Context());
2020-06-04 22:07:00 +02:00
}
2016-12-17 04:16:29 +01:00
/**
2019-03-01 21:55:20 +01:00
* @return iterable<string,array{string,assertions?:array<string,string>,error_levels?:string[]}>
2016-12-17 04:16:29 +01:00
*/
public function providerValidCodeParse(): iterable
2016-12-17 04:16:29 +01:00
{
return [
'notInCallMapTest' => [
'<?php
Refactor scanning and analysis, introducing multithreading (#191) * Add failing test * Add visitor to soup up classlike references * Move a whole bunch of code into the visitor * Move some methods back, move onto analysis stage * Use the getAliases method everywhere * Fix refs * Fix more refs * Fix some tests * Fix more tests * Fix include tests * Shift config class finding to project checker and fix bugs * Fix a few more tests * transition test to new syntax * Remove var_dump * Delete a bunch of code and fix mutation test * Remove unnecessary visitation * Transition to better mocked out file provider, breaking some cached statement loading * Use different scheme for naming anonymous classes * Fix anonymous class issues * Refactor file/statement loading * Add specific property types * Fix mapped property assignment * Improve how we deal with traits * Fix trait checking * Pass Psalm checks * Add multi-process support * Delay console output until the end * Remove PHP 7 syntax * Update file storage with classes * Fix scanning individual files and add reflection return types * Always turn XDebug off * Add quicker method of getting method mutations * Queue return types for crawling * Interpret all strings as possible classes once we see a `get_class` call * Check invalid return types again * Fix template namespacing issues * Default to class-insensitive file names for includes * Don’t overwrite existing issues data * Add var docblocks for scanning * Add null check * Fix loading of external classes in templates * Only try to populate class when we haven’t yet seen it’s not a class * Fix trait property accessibility * Only ever improve docblock param type * Make param replacement more robust * Fix static const missing inferred type * Fix a few more tests * Register constant definitions * Fix trait aliasing * Skip constant type tests for now * Fix linting issues * Make sure caching is off for tests * Remove unnecessary return * Use emulative parser if on PHP 5.6 * Cache parser for faster first-time parse * Fix constant resolution when scanning classes * Remove test that’s beyond a practical scope * Add back --diff support * Add --help for --threads * Remove unused vars
2017-07-25 22:11:02 +02:00
new DOMImplementation();',
],
'parentStaticCall' => [
'<?php
class A {
/** @return void */
public static function foo(){}
}
class B extends A {
/** @return void */
public static function bar(){
parent::foo();
}
2017-05-27 02:05:57 +02:00
}',
],
'nonStaticInvocation' => [
'<?php
class Foo {
2018-01-11 21:50:45 +01:00
public static function barBar(): void {}
}
2017-05-27 02:05:57 +02:00
(new Foo())->barBar();',
],
'staticInvocation' => [
'<?php
class A {
2018-01-11 21:50:45 +01:00
public static function fooFoo(): void {}
}
class B extends A {
}
2017-05-27 02:05:57 +02:00
B::fooFoo();',
],
'staticCallOnVar' => [
'<?php
class A {
2018-01-11 21:50:45 +01:00
public static function bar(): int {
return 5;
}
}
$foo = new A;
$b = $foo::bar();',
],
'uppercasedSelf' => [
'<?php
class X33{
2018-01-11 21:50:45 +01:00
public static function main(): void {
echo SELF::class . "\n"; // Class or interface SELF does not exist
}
}
X33::main();',
],
'dateTimeImmutableStatic' => [
'<?php
2020-03-09 14:45:35 +01:00
/** @psalm-immutable */
final class MyDate extends DateTimeImmutable {}
$today = new MyDate();
2018-01-05 17:50:27 +01:00
$yesterday = $today->sub(new DateInterval("P1D"));
$b = (new DateTimeImmutable())->modify("+3 hours");',
'assertions' => [
'$yesterday' => 'MyDate|false',
2018-01-05 17:50:27 +01:00
'$b' => 'DateTimeImmutable',
],
],
2018-01-22 06:17:16 +01:00
'magicCall' => [
'<?php
class A {
2020-03-11 23:42:41 +01:00
public function __call(string $method_name, array $args) : string {
return "hello";
}
2018-01-22 06:17:16 +01:00
}
$a = new A;
2020-03-11 23:42:41 +01:00
$s = $a->bar();',
[
'$s' => 'string',
]
2018-01-22 06:17:16 +01:00
],
'canBeCalledOnMagic' => [
'<?php
class A {
public function __call(string $method, array $args) {}
}
class B {}
$a = rand(0, 1) ? new A : new B;
$a->maybeUndefinedMethod();',
'assertions' => [],
'error_levels' => ['PossiblyUndefinedMethod'],
],
'canBeCalledOnMagicWithMethod' => [
'<?php
class A {
public function __call(string $method, array $args) {}
}
class B {
public function bar() : void {}
}
$a = rand(0, 1) ? new A : new B;
$a->bar();',
'assertions' => [],
],
2018-04-01 00:57:13 +02:00
'invokeCorrectType' => [
'<?php
class A {
public function __invoke(string $p): void {}
}
$q = new A;
$q("asda");',
],
'domDocumentAppendChild' => [
'<?php
$doc = new DOMDocument("1.0");
$node = $doc->createElement("foo");
if ($node instanceof DOMElement) {
$newnode = $doc->appendChild($node);
$newnode->setAttribute("bar", "baz");
}',
],
'nonStaticSelfCall' => [
'<?php
class A11 {
public function call() : self {
$result = self::method();
return $result;
}
public function method() : self {
return $this;
}
}
$x = new A11();
var_export($x->call());',
],
2018-06-06 05:42:02 +02:00
'simpleXml' => [
'<?php
$xml = new SimpleXMLElement("<a><b></b></a>");
$a = $xml->asXML();
$b = $xml->asXML("foo.xml");',
'assertions' => [
'$a' => 'false|string',
'$b' => 'bool',
2018-06-06 05:42:02 +02:00
],
],
'datetimeformatNotFalse' => [
'<?php
$format = random_bytes(10);
$dt = new DateTime;
$formatted = $dt->format($format);
if (false !== $formatted) {}
function takesString(string $s) : void {}
2019-03-23 19:27:54 +01:00
takesString($formatted);',
'assertions' => [],
'error_levels' => [],
'php_version' => '7.4'
],
2018-07-06 05:02:09 +02:00
'domElement' => [
'<?php
function foo(DOMElement $e) : ?string {
$a = $e->getElementsByTagName("bar");
$b = $a->item(0);
if (!$b) {
return null;
}
return $b->getAttribute("bat");
}',
],
'domElementIteratorOrEmptyArray' => [
'<?php
/** @param non-empty-string $XML */
function foo(string $XML) : void {
$dom = new DOMDocument();
$dom->loadXML($XML);
$elements = rand(0, 1) ? $dom->getElementsByTagName("bar") : [];
foreach ($elements as $element) {
$element->getElementsByTagName("bat");
}
2019-03-23 19:27:54 +01:00
}',
],
'reflectionParameter' => [
'<?php
function getTypeName(ReflectionParameter $parameter): string {
$type = $parameter->getType();
if ($type === null) {
return "mixed";
}
if ($type instanceof ReflectionUnionType) {
return "union";
}
if ($type instanceof ReflectionNamedType) {
return $type->getName();
}
throw new RuntimeException("unexpected type");
2019-03-23 19:27:54 +01:00
}',
'assertions' => [],
'error_levels' => [],
'php_version' => '8.0'
],
'PDOMethod' => [
'<?php
function md5_and_reverse(string $string) : string {
return strrev(md5($string));
}
$db = new PDO("sqlite:sqlitedb");
$db->sqliteCreateFunction("md5rev", "md5_and_reverse", 1);',
],
2018-12-11 00:33:26 +01:00
'dontConvertedMaybeMixedAfterCall' => [
'<?php
class B {
public function foo() : void {}
}
/**
* @param array<B> $b
*/
function foo(array $a, array $b) : void {
$c = array_merge($b, $a);
foreach ($c as $d) {
$d->foo();
if ($d instanceof B) {}
}
}',
[],
'error_levels' => ['MixedAssignment', 'MixedMethodCall'],
],
'methodResolution' => [
'<?php
interface ReturnsString {
public function getId(): string;
}
/**
* @param mixed $a
*/
function foo(ReturnsString $user, $a): string {
strlen($user->getId());
(is_object($a) && method_exists($a, "getS")) ? (string)$a->getS() : "";
return $user->getId();
2019-03-23 19:27:54 +01:00
}',
],
'defineVariableCreatedInArgToMixed' => [
'<?php
function bar($a) : void {
if ($a->foo($b = (int) "5")) {
echo $b;
}
}',
[],
'error_levels' => ['MixedMethodCall', 'MissingParamType'],
],
'staticCallAfterMethodExists' => [
'<?php
class A
{
protected static function existing() : string
{
return "hello";
}
protected static function foo() : string
{
if (!method_exists(static::class, "maybeExists")) {
return "hello";
}
self::maybeExists();
return static::existing();
}
2019-03-23 19:27:54 +01:00
}',
],
'varSelfCall' => [
'<?php
class Foo {
/** @var self */
public static $current;
public function bar() : void {}
}
Foo::$current->bar();',
],
'pdoStatementSetFetchMode' => [
'<?php
class A {
/** @var ?string */
public $a;
}
$db = new PDO("sqlite::memory:");
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $db->prepare("select \"a\" as a");
$stmt->setFetchMode(PDO::FETCH_CLASS, A::class);
$stmt->execute();
/** @psalm-suppress MixedAssignment */
2019-07-05 22:24:00 +02:00
$a = $stmt->fetch();',
],
'datePeriodConstructor' => [
'<?php
function foo(DateTime $d1, DateTime $d2) : void {
new DatePeriod(
$d1,
DateInterval::createFromDateString("1 month"),
$d2
);
2019-07-05 22:24:00 +02:00
}',
],
'callMethodAfterCheckingExistence' => [
'<?php
class A {}
function foo(A $a) : void {
if (method_exists($a, "bar")) {
/** @psalm-suppress MixedArgument */
echo $a->bar();
}
}'
],
'callMethodAfterCheckingExistenceInClosure' => [
'<?php
class A {}
function foo(A $a) : void {
if (method_exists($a, "bar")) {
(function() use ($a) : void {
/** @psalm-suppress MixedArgument */
echo $a->bar();
})();
}
}'
],
'callManyMethodsAfterCheckingExistence' => [
'<?php
function foo(object $object) : void {
if (!method_exists($object, "foo")) {
return;
}
if (!method_exists($object, "bar")) {
return;
}
$object->foo();
$object->bar();
}'
],
'callManyMethodsAfterCheckingExistenceChained' => [
'<?php
function foo(object $object) : void {
if (method_exists($object, "foo") && method_exists($object, "bar")) {
$object->foo();
$object->bar();
}
}'
],
'callManyMethodsOnKnownObjectAfterCheckingExistenceChained' => [
'<?php
class A {}
function foo(A $object) : void {
if (method_exists($object, "foo") && method_exists($object, "bar")) {
$object->foo();
$object->bar();
}
}'
],
'preserveMethodExistsType' => [
'<?php
/**
* @param class-string $foo
*/
function foo(string $foo): string {
if (!method_exists($foo, "something")) {
return "";
}
return $foo;
}'
],
'methodDoesNotExistOnClass' => [
'<?php
class A {}
/**
* @param class-string<A> $foo
*/
function foo(string $foo): string {
if (!method_exists($foo, "something")) {
return "";
}
return $foo;
}'
],
'pdoStatementFetchAssoc' => [
'<?php
/** @return array<string,null|scalar>|false */
function fetch_assoc() {
$p = new PDO("sqlite::memory:");
$sth = $p->prepare("SELECT 1");
$sth->execute();
return $sth->fetch(PDO::FETCH_ASSOC);
}'
],
'pdoStatementFetchBoth' => [
'<?php
/** @return array<null|scalar>|false */
function fetch_both() {
$p = new PDO("sqlite::memory:");
$sth = $p->prepare("SELECT 1");
$sth->execute();
return $sth->fetch(PDO::FETCH_BOTH);
}'
],
'pdoStatementFetchBound' => [
'<?php
/** @return bool */
function fetch_both() : bool {
$p = new PDO("sqlite::memory:");
$sth = $p->prepare("SELECT 1");
$sth->execute();
return $sth->fetch(PDO::FETCH_BOUND);
}'
],
'pdoStatementFetchClass' => [
'<?php
/** @return object|false */
function fetch_class() {
$p = new PDO("sqlite::memory:");
$sth = $p->prepare("SELECT 1");
$sth->execute();
return $sth->fetch(PDO::FETCH_CLASS);
}'
],
'pdoStatementFetchLazy' => [
'<?php
/** @return object|false */
function fetch_lazy() {
$p = new PDO("sqlite::memory:");
$sth = $p->prepare("SELECT 1");
$sth->execute();
return $sth->fetch(PDO::FETCH_LAZY);
}'
],
'pdoStatementFetchNamed' => [
'<?php
/** @return array<string,scalar|list<scalar>>|false */
function fetch_named() {
$p = new PDO("sqlite::memory:");
$sth = $p->prepare("SELECT 1");
$sth->execute();
return $sth->fetch(PDO::FETCH_NAMED);
}'
],
'pdoStatementFetchNum' => [
'<?php
/** @return list<null|scalar>|false */
function fetch_named() {
$p = new PDO("sqlite::memory:");
$sth = $p->prepare("SELECT 1");
$sth->execute();
return $sth->fetch(PDO::FETCH_NUM);
}'
],
'pdoStatementFetchObj' => [
'<?php
/** @return stdClass|false */
function fetch_named() {
$p = new PDO("sqlite::memory:");
$sth = $p->prepare("SELECT 1");
$sth->execute();
return $sth->fetch(PDO::FETCH_OBJ);
}'
],
'dateTimeSecondArg' => [
'<?php
$date = new DateTime(null, new DateTimeZone("Pacific/Nauru"));
echo $date->format("Y-m-d H:i:sP") . "\n";'
],
2020-02-27 14:59:43 +01:00
'noCrashOnGetClassMethodCallWithNull' => [
'<?php
class User {
/**
* @psalm-suppress NullArgument
*/
public function give(): void{
$model = null;
$class = \get_class($model);
$class::foo();
}
}',
],
'unknownMethodCallWithProperty' => [
'<?php
class A {
private string $b = "c";
public function passesByRef(object $a): void {
/** @psalm-suppress MixedMethodCall */
$a->passedByRef($this->b);
}
}',
],
'maybeNotTooManyArgumentsToInstance' => [
'<?php
class A {
public function fooFoo(int $a): void {}
}
class B {
public function fooFoo(int $a, string $s): void {}
}
(rand(0, 1) ? new A : new B)->fooFoo(5, "dfd");',
],
'interfaceMethodCallCheck' => [
'<?php
interface A {
function foo() : void;
}
interface B extends A {
function foo(string $a = "") : void;
}
class C implements B {
public function foo(string $a = "") : void {}
}
function takesWithoutArguments(A $a) : void {
if ($a instanceof B) {
$a->foo("");
}
}
takesWithoutArguments(new C);'
],
'getterAutomagicAssertion' => [
'<?php
class A {
/** @var string|null */
public $a;
/** @return string|null */
final public function getA() {
return $this->a;
}
}
$a = new A();
if ($a->getA()) {
echo strlen($a->getA());
}'
],
'ignorePossiblyNull' => [
'<?php
class Foo {
protected ?string $type = null;
public function prepend(array $arr) : string {
return $this->getType();
}
/**
* @psalm-ignore-nullable-return
*/
public function getType() : ?string
{
return $this->type;
}
}'
],
'abstractMethodExistsOnChild' => [
'<?php
abstract class Foo {}
abstract class FooChild extends Foo {}
abstract class AbstractTestCase {
abstract public function createFoo(): Foo;
}
abstract class AbstractChildTestCase extends AbstractTestCase {
abstract public function createFoo(): FooChild;
public function testFoo(): FooChild {
return $this->createFoo();
}
}',
[],
[],
'7.4'
],
'pdoQueryTwoArgs' => [
'<?php
$pdo = new PDO("test");
$pdo->query("SELECT * FROM projects", PDO::FETCH_NAMED);'
],
'unchainedInferredMutationFreeMethodCallMemoize' => [
'<?php
class SomeClass {
private ?int $int;
public function __construct() {
$this->int = 1;
}
/**
* @psalm-mutation-free
*/
public function getInt(): ?int {
return $this->int;
}
}
function printInt(int $int): void {
echo $int;
}
$obj = new SomeClass();
if ($obj->getInt()) {
printInt($obj->getInt());
}',
],
'unchainedInferredInferredFinalMutationFreeMethodCallMemoize' => [
'<?php
class SomeClass {
private ?int $int;
public function __construct() {
$this->int = 1;
}
final public function getInt(): ?int {
return $this->int;
}
}
function printInt(int $int): void {
echo $int;
}
$obj = new SomeClass();
if ($obj->getInt()) {
printInt($obj->getInt());
}',
],
'privateInferredMutationFreeMethodCallMemoize' => [
'<?php
class PropertyClass {
public function test() : void {
echo "test";
}
}
class SomeClass {
private ?PropertyClass $property = null;
private function getProperty(): ?PropertyClass {
return $this->property;
}
public function test(int $int): void {
if ($this->getProperty() !== null) {
$this->getProperty()->test();
}
}
}',
],
'inferredFinalMethod' => [
'<?php
class PropertyClass {
public function test() : bool {
return true;
}
}
class MainClass {
private ?PropertyClass $property = null;
final public function getProperty(): ?PropertyClass {
return $this->property;
}
}
$main = new MainClass();
if ($main->getProperty() !== null && $main->getProperty()->test()) {}'
],
'getterTypeInferring' => [
'<?php
class A {
/** @var int|string|null */
public $a;
/** @return int|string|null */
final public function getValue() {
return $this->a;
}
}
$a = new A();
if (is_string($a->getValue())) {
echo strlen($a->getValue());
}',
],
'newSplObjectStorageDefaultEmpty' => [
'<?php
$a = new SplObjectStorage();',
[
'$a' => 'SplObjectStorage<empty, empty>',
]
],
'allowIteratorToBeNull' => [
'<?php
/**
* @return Iterator<string>
*/
function buildIterator(int $size): Iterator {
$values = [];
for ($i = 0; $i < $size; $i++) {
$values[] = "Item $i\n";
}
return new ArrayIterator($values);
}
$it = buildIterator(2);
if ($it->current() === null) {}'
],
'resolveFinalInParentCall' => [
'<?php
abstract class A {
protected static function create() : static {
return new static();
}
final private function __construct() {}
}
final class B extends A {
public static function new() : self {
return parent::create();
}
}'
],
'noCrashWhenCallingParent' => [
'<?php
namespace FooBar;
class Datetime extends \DateTime
{
public static function createFromInterface(\DatetimeInterface $datetime): \DateTime
{
return parent::createFromInterface($datetime);
}
}',
[],
['MixedReturnStatement', 'MixedInferredReturnType'],
'8.0'
],
'nullsafeShortCircuit' => [
'<?php
interface Bar {
public function doBaz(): void;
}
interface Foo {
public function getBar(): Bar;
}
function fooOrNull(): ?Foo {
return null;
}
fooOrNull()?->getBar()->doBaz();',
[],
[],
'8.0'
],
'parentMagicMethodCall' => [
'<?php
class Model {
/**
* @return static
*/
public function __call(string $method, array $args) {
/** @psalm-suppress UnsafeInstantiation */
return new static;
}
}
class BlahModel extends Model {
/**
* @param mixed $input
*/
public function create($input): BlahModel
{
return parent::create([]);
}
}
$m = new BlahModel();
$n = $m->create([]);',
[
'$n' => 'BlahModel',
]
],
];
2016-12-17 04:16:29 +01:00
}
/**
* @return iterable<string,array{string,error_message:string,1?:string[],2?:bool,3?:string}>
*/
public function providerInvalidCodeParse(): iterable
{
return [
'staticInvocation' => [
'<?php
class Foo {
2018-01-11 21:50:45 +01:00
public function barBar(): void {}
}
Foo::barBar();',
2017-05-27 02:05:57 +02:00
'error_message' => 'InvalidStaticInvocation',
],
'parentStaticCall' => [
'<?php
class A {
/** @return void */
public function foo(){}
}
class B extends A {
/** @return void */
public static function bar(){
parent::foo();
}
}',
2017-05-27 02:05:57 +02:00
'error_message' => 'InvalidStaticInvocation',
],
'mixedMethodCall' => [
'<?php
class Foo {
2018-01-11 21:50:45 +01:00
public static function barBar(): void {}
}
/** @var mixed */
$a = (new Foo());
$a->barBar();',
'error_message' => 'MixedMethodCall',
'error_levels' => [
'MissingPropertyType',
2017-05-27 02:05:57 +02:00
'MixedAssignment',
],
],
'invalidMethodCall' => [
'<?php
("hello")->someMethod();',
'error_message' => 'InvalidMethodCall',
],
'possiblyInvalidMethodCall' => [
'<?php
class A1 {
public function methodOfA(): void {
}
}
/** @param A1|string $x */
function example($x, bool $isObject) : void {
if ($isObject) {
$x->methodOfA();
}
}',
'error_message' => 'PossiblyInvalidMethodCall',
],
'selfNonStaticInvocation' => [
'<?php
class A {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void {}
public static function barBar(): void {
self::fooFoo();
}
}',
2017-05-27 02:05:57 +02:00
'error_message' => 'NonStaticSelfCall',
],
'noParent' => [
'<?php
class Foo {
2018-01-11 21:50:45 +01:00
public function barBar(): void {
parent::barBar();
}
}',
2017-05-27 02:05:57 +02:00
'error_message' => 'ParentNotFound',
],
'coercedClass' => [
'<?php
class NullableClass {
}
class NullableBug {
/**
* @param class-string|null $className
* @return object|null
*/
public static function mock($className) {
if (!$className) { return null; }
return new $className();
}
/**
* @return ?NullableClass
*/
public function returns_nullable_class() {
/** @psalm-suppress ArgumentTypeCoercion */
return self::mock("NullableClass");
}
}',
'error_message' => 'LessSpecificReturnStatement',
'error_levels' => ['MixedInferredReturnType', 'MixedReturnStatement', 'MixedMethodCall'],
2017-05-27 02:05:57 +02:00
],
'undefinedVariableStaticCall' => [
'<?php
$foo::bar();',
'error_message' => 'UndefinedGlobalVariable',
],
'staticCallOnString' => [
'<?php
class A {
2018-01-11 21:50:45 +01:00
public static function bar(): int {
return 5;
}
}
$foo = "A";
/** @psalm-suppress InvalidStringClass */
$b = $foo::bar();',
'error_message' => 'MixedAssignment',
],
2018-01-22 06:17:16 +01:00
'possiblyNullFunctionCall' => [
'<?php
$this->foo();',
'error_message' => 'InvalidScope',
],
'possiblyFalseReference' => [
'<?php
class A {
public function bar(): void {}
}
$a = rand(0, 1) ? new A : false;
$a->bar();',
'error_message' => 'PossiblyFalseReference',
],
'undefinedParentClass' => [
'<?php
/**
* @psalm-suppress UndefinedClass
*/
class B extends A {}
$b = new B();',
'error_message' => 'MissingDependency - src' . DIRECTORY_SEPARATOR . 'somefile.php:7',
],
'variableMethodCallOnArray' => [
'<?php
$arr = [];
$b = "foo";
$arr->$b();',
'error_message' => 'InvalidMethodCall',
],
'intVarStaticCall' => [
'<?php
$a = 5;
$a::bar();',
'error_message' => 'UndefinedClass',
],
'intVarNewCall' => [
'<?php
$a = 5;
new $a();',
'error_message' => 'UndefinedClass',
],
2018-04-01 00:57:13 +02:00
'invokeTypeMismatch' => [
'<?php
class A {
public function __invoke(string $p): void {}
}
$q = new A;
$q(1);',
'error_message' => 'InvalidScalarArgument',
],
'explicitInvokeTypeMismatch' => [
'<?php
class A {
public function __invoke(string $p): void {}
}
(new A)->__invoke(1);',
'error_message' => 'InvalidScalarArgument',
],
'undefinedMethodPassedAsArg' => [
'<?php
class A {
public function __call(string $method, array $args) {}
}
$q = new A;
$q->foo(bar());',
2019-03-23 19:27:54 +01:00
'error_message' => 'UndefinedFunction',
],
'noIntersectionMethod' => [
'<?php
interface A {}
interface B {}
/** @param B&A $p */
function f($p): void {
$p->zugzug();
}',
2019-03-23 19:27:54 +01:00
'error_message' => 'UndefinedInterfaceMethod - src' . DIRECTORY_SEPARATOR . 'somefile.php:7:29 - Method (B&A)::zugzug does not exist',
],
'noInstanceCallAsStatic' => [
'<?php
class C {
public function foo() : void {}
}
(new C)::foo();',
'error_message' => 'InvalidStaticInvocation',
],
'noExceptionOnMissingClass' => [
'<?php
/** @psalm-suppress UndefinedClass */
class A
{
/** @var class-string<Foo> */
protected $bar;
public function foo(string $s): void
{
$bar = $this->bar;
$bar::baz();
}
}',
'error_message' => 'MissingConstructor',
],
'checkMixedMethodCallStaticMethodCallArg' => [
'<?php
class B {}
/** @param mixed $a */
function foo($a) : void {
/** @psalm-suppress MixedMethodCall */
$a->bar(B::bat());
}',
'error_message' => 'UndefinedMethod',
],
'complainAboutUndefinedPropertyOnMixedCall' => [
'<?php
class C {
/** @param mixed $a */
public function foo($a) : void {
/** @psalm-suppress MixedMethodCall */
$a->bar($this->d);
}
}',
'error_message' => 'UndefinedThisPropertyFetch',
],
2019-07-23 00:04:52 +02:00
'complainAboutUndefinedPropertyOnMixedCallConcatOp' => [
'<?php
class A {
/**
* @psalm-suppress MixedMethodCall
*/
public function foo(object $a) : void {
$a->bar("bat" . $this->baz);
}
}',
'error_message' => 'UndefinedThisPropertyFetch',
],
'alreadyHasmethod' => [
'<?php
class A {
public function foo() : void {}
}
function foo(A $a) : void {
if (method_exists($a, "foo")) {
$object->foo();
}
}',
'error_message' => 'RedundantCondition',
],
'possiblyNullOrMixedArg' => [
'<?php
class A {
/**
* @var mixed
*/
public $foo;
}
function takesString(string $s) : void {}
function takesA(?A $a) : void {
/**
* @psalm-suppress PossiblyNullPropertyFetch
* @psalm-suppress MixedArgument
*/
takesString($a->foo);
}',
'error_message' => 'PossiblyNullArgument',
],
2019-11-01 14:05:28 +01:00
'callOnVoid' => [
'<?php
class A {
public function foo(): void {}
}
$p = new A();
$p->foo()->bar();',
'error_message' => 'NullReference'
],
'dateTimeNullFirstArg' => [
'<?php
$date = new DateTime(null);',
'error_message' => 'NullArgument'
],
'noCrashOnGetClassMethodCall' => [
'<?php
class User {
/**
* @psalm-suppress MixedArgument
*/
public function give(): void{
/** @var mixed */
$model = null;
$class = \get_class($model);
$class::foo();
}
}',
'error_message' => 'InvalidStringClass',
],
'preventAbstractMethodCall' => [
'<?php
abstract class Base {
public static function callAbstract() : void {
static::bar();
}
abstract static function bar() : void;
}
Base::bar();',
'error_message' => 'AbstractMethodCall',
],
'tooManyArgumentsToStatic' => [
'<?php
class A {
public static function fooFoo(int $a): void {}
}
A::fooFoo(5, "dfd");',
'error_message' => 'TooManyArguments',
],
'tooFewArgumentsToStatic' => [
'<?php
class A {
public static function fooFoo(int $a): void {}
}
A::fooFoo();',
'error_message' => 'TooFewArguments',
],
'tooManyArgumentsToInstance' => [
'<?php
class A {
public function fooFoo(int $a): void {}
}
(new A)->fooFoo(5, "dfd");',
'error_message' => 'TooManyArguments',
],
'tooFewArgumentsToInstance' => [
'<?php
class A {
public function fooFoo(int $a): void {}
}
(new A)->fooFoo();',
'error_message' => 'TooFewArguments',
],
'getterAutomagicOverridden' => [
'<?php
class A {
/** @var string|null */
public $a;
/** @return string|null */
function getA() {
return $this->a;
}
}
class AChild extends A {
function getA() {
return rand(0, 1) ? $this->a : null;
}
}
function foo(A $a) : void {
if ($a->getA()) {
echo strlen($a->getA());
}
}
foo(new AChild());',
'error_message' => 'PossiblyNullArgument'
],
'getterAutomagicOverriddenWithAssertion' => [
'<?php
class A {
/** @var string|null */
public $a;
/** @psalm-assert-if-true string $this->a */
function hasA() {
return is_string($this->a);
}
/** @return string|null */
function getA() {
return $this->a;
}
}
class AChild extends A {
function getA() {
return rand(0, 1) ? $this->a : null;
}
}
function foo(A $a) : void {
if ($a->hasA()) {
echo strlen($a->getA());
}
}
foo(new AChild());',
'error_message' => 'PossiblyNullArgument'
],
'checkVariableInUnknownClassConstructor' => [
'<?php
/** @psalm-suppress UndefinedClass */
new Missing($class_arg);',
'error_message' => 'PossiblyUndefinedVariable',
],
'unchainedInferredInferredMutationFreeMethodCallDontMemoize' => [
'<?php
class SomeClass {
private ?int $int;
public function __construct() {
$this->int = 1;
}
public function getInt(): ?int {
return $this->int;
}
}
function printInt(int $int): void {
echo $int;
}
$obj = new SomeClass();
if ($obj->getInt()) {
printInt($obj->getInt());
}',
'error_message' => 'PossiblyNullArgument',
],
'getterTypeInferringWithChange' => [
'<?php
class A {
/** @var int|string|null */
public $val;
/** @return int|string|null */
final public function getValue() {
return $this->val;
}
}
$a = new A();
if (is_string($a->getValue())) {
$a->val = 5;
echo strlen($a->getValue());
}',
'error_message' => 'InvalidScalarArgument',
],
'possiblyNullReferenceInInvokedCall' => [
'<?php
interface Location {
public function getId(): int;
}
/** @psalm-immutable */
interface Application {
public function getLocation(): ?Location;
}
interface TakesId {
public function __invoke(int $location): int;
}
function f(TakesId $takesId, Application $application): void {
($takesId)($application->getLocation()->getId());
}',
'error_message' => 'PossiblyNullReference',
],
'nullsafeShortCircuitInVariable' => [
'<?php
interface Bar {
public function doBaz(): void;
}
interface Foo {
public function getBar(): Bar;
}
function fooOrNull(): ?Foo {
return null;
}
$a = fooOrNull()?->getBar();
$a->doBaz();',
'error_message' => 'PossiblyNullReference',
[],
false,
'8.0'
],
'undefinedMethodOnParentCallWithMethodExistsOnSelf' => [
'<?php
class A {}
class B extends A {
public function foo(): string {
return parent::foo();
}
}',
'error_message' => 'UndefinedMethod',
],
];
}
2016-12-12 05:41:11 +01:00
}