1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-13 09:47:29 +01:00
psalm/tests/TraitTest.php

1187 lines
35 KiB
PHP
Raw Normal View History

2016-12-17 04:16:29 +01:00
<?php
namespace Psalm\Tests;
use const DIRECTORY_SEPARATOR;
class TraitTest extends TestCase
2016-12-17 04:16:29 +01:00
{
2018-11-06 03:57:36 +01:00
use Traits\InvalidCodeAnalysisTestTrait;
use Traits\ValidCodeAnalysisTestTrait;
2016-12-17 04:16:29 +01:00
2017-01-13 20:07:23 +01:00
/**
2019-03-01 21:55:20 +01:00
* @return iterable<string,array{string,assertions?:array<string,string>,error_levels?:string[]}>
2017-01-13 20:07:23 +01:00
*/
public function providerValidCodeParse(): iterable
2016-12-17 04:16:29 +01:00
{
return [
'accessiblePrivateMethodFromTrait' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
private function fooFoo(): void {
}
}
class B {
use T;
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
$this->fooFoo();
}
2017-05-27 02:05:57 +02:00
}',
],
'accessibleProtectedMethodFromTrait' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
protected function fooFoo(): void {
}
}
class B {
use T;
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
$this->fooFoo();
}
2017-05-27 02:05:57 +02:00
}',
],
'accessiblePublicMethodFromTrait' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void {
}
}
class B {
use T;
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
$this->fooFoo();
}
2017-05-27 02:05:57 +02:00
}',
],
'accessiblePrivatePropertyFromTrait' => [
'<?php
trait T {
/** @var string */
private $fooFoo = "";
}
class B {
use T;
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
echo $this->fooFoo;
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
$this->fooFoo = "hello";
}
2017-05-27 02:05:57 +02:00
}',
],
'accessibleProtectedPropertyFromTrait' => [
'<?php
trait T {
/** @var string */
protected $fooFoo = "";
}
class B {
use T;
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
echo $this->fooFoo;
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
$this->fooFoo = "hello";
}
2017-05-27 02:05:57 +02:00
}',
],
'accessiblePublicPropertyFromTrait' => [
'<?php
trait T {
/** @var string */
public $fooFoo = "";
}
class B {
use T;
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
echo $this->fooFoo;
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
$this->fooFoo = "hello";
}
2017-05-27 02:05:57 +02:00
}',
],
'accessibleProtectedMethodFromInheritedTrait' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
protected function fooFoo(): void {
}
}
class B {
use T;
}
class C extends B {
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
$this->fooFoo();
}
2017-05-27 02:05:57 +02:00
}',
],
'accessiblePublicMethodFromInheritedTrait' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void {
}
}
class B {
use T;
}
class C extends B {
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
$this->fooFoo();
}
2017-05-27 02:05:57 +02:00
}',
],
'staticClassMethodFromWithinTrait' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void {
self::barBar();
}
}
class B {
use T;
2018-01-11 21:50:45 +01:00
public static function barBar(): void {
}
2017-05-27 02:05:57 +02:00
}',
],
'redefinedTraitMethodWithoutAlias' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void {
}
}
class B {
use T;
2018-01-11 21:50:45 +01:00
public function fooFoo(string $a): void {
}
}
2017-05-27 02:05:57 +02:00
(new B)->fooFoo("hello");',
],
'redefinedTraitMethodWithAlias' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void {
}
}
class B {
use T {
fooFoo as barBar;
}
2018-01-11 21:50:45 +01:00
public function fooFoo(): void {
$this->barBar();
}
2017-05-27 02:05:57 +02:00
}',
],
'traitSelf' => [
'<?php
trait T {
public function g(): self
{
return $this;
}
}
class A {
use T;
}
$a = (new A)->g();',
'assertions' => [
2017-06-29 16:22:49 +02:00
'$a' => 'A',
2017-05-27 02:05:57 +02:00
],
],
'parentTraitSelf' => [
'<?php
trait T {
public function g(): self
{
return $this;
}
}
class A {
use T;
}
class B extends A {
}
class C {
use T;
}
$a = (new B)->g();',
'assertions' => [
2017-06-29 16:22:49 +02:00
'$a' => 'A',
2017-05-27 02:05:57 +02:00
],
],
'directStaticCall' => [
'<?php
trait T {
/** @return void */
public static function foo() {}
}
class A {
use T;
/** @return void */
public function bar() {
T::foo();
}
2017-05-27 02:05:57 +02:00
}',
],
'abstractTraitMethod' => [
'<?php
trait T {
/** @return void */
abstract public function foo();
}
abstract class A {
use T;
/** @return void */
public function bar() {
$this->foo();
}
2017-05-27 02:05:57 +02:00
}',
],
'instanceOfTraitUser' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function f(): void {
if ($this instanceof A) { }
}
}
class A {
use T;
}
class B {
use T;
}',
],
'getClassTraitUser' => [
'<?php
trait T {
public function f(): void {
if (get_class($this) === B::class) {
$this->foo();
}
}
}
class A {
use T;
}
class B {
use T;
public function foo() : void {}
}',
],
'staticClassTraitUser' => [
'<?php
trait T {
public function f(): void {
if (static::class === B::class) {
$this->foo();
}
}
}
class A {
use T;
}
class B {
use T;
public function foo() : void {}
}',
],
'isAClassTraitUserStringClass' => [
'<?php
trait T {
public function f(): void {
if (is_a(static::class, "B")) { }
}
}
class A {
use T;
}
class B {
use T;
public function foo() : void {}
}',
],
'isAClassTraitUserClassConstant' => [
'<?php
trait T {
public function f(): void {
if (is_a(static::class, "B")) { }
}
}
class A {
use T;
}
class B {
use T;
public function foo() : void {}
}',
],
'useTraitInClassWithAbstractMethod' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
abstract public function foo(): void;
}
class A {
2018-01-11 21:50:45 +01:00
public function foo(): void {}
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
}',
],
'useTraitInSubclassWithAbstractMethod' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
abstract public function foo(): void;
}
abstract class A {
2018-01-11 21:50:45 +01:00
public function foo(): void {}
}
class B extends A {
use T;
}',
],
'useTraitInSubclassWithAbstractMethodInParent' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function foo(): void {}
}
abstract class A {
2018-01-11 21:50:45 +01:00
abstract public function foo(): void {}
}
class B extends A {
use T;
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
}',
],
'differentMethodReturnTypes' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public static function getSelf(): self {
return new self();
}
2018-01-11 21:50:45 +01:00
public static function callGetSelf(): self {
return self::getSelf();
}
}
class A {
use T;
}
class B {
use T;
}',
],
'parentRefInTraitShouldNotFail' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function foo(): void {
parent::foo();
}
}
class A {
2018-01-11 21:50:45 +01:00
public function foo(): void {}
}
class B extends A {
use T;
}',
],
2018-01-21 06:32:45 +01:00
'namespacedTraitLookup' => [
'<?php
namespace Classes {
use Traits\T;
class A {}
class B {
use T;
}
}
namespace Traits {
use Classes\A;
trait T {
public function getA() : A {
return new A;
}
}
}
namespace {
$a = (new Classes\B)->getA();
}',
],
'useAndMap' => [
'<?php
class C
{
use T2;
2020-03-03 05:07:21 +01:00
use T1 {
2020-03-03 05:07:21 +01:00
traitFunc as aliasedTraitFunc;
}
public static function func(): void
{
2020-03-03 05:07:21 +01:00
static::aliasedTraitFunc();
}
}
trait T1
{
public static function traitFunc(): void {}
}
trait T2 { }',
],
'mapAndUse' => [
'<?php
class C
{
use T1 {
traitFunc as _func;
}
use T2;
public static function func(): void
{
static::_func();
}
}
trait T1
{
public static function traitFunc(): void {}
}
trait T2 { }',
],
'moreArgsInDefined' => [
'<?php
trait T {
abstract public function foo() : void;
public function callFoo() : void {
$this->foo();
}
}
class A {
use T;
public function foo(string $s = null) : void {
}
}',
],
2018-03-21 21:55:31 +01:00
'aliasedMethodInternalCallNoReplacement' => [
'<?php
trait T {
public function foo() : int {
return $this->bar();
}
public function bar() : int {
return 3;
}
}
class A {
use T {
bar as bat;
}
public function baz() : int {
return $this->bar();
}
}',
],
'aliasedMethodInternalCallWithLocalDefinition' => [
'<?php
trait T {
public function bar() : int {
return 3;
}
}
class A {
use T {
bar as bat;
}
public function bar() : string {
return "hello";
}
public function baz() : string {
return $this->bar();
}
}',
],
'allMethodsReplaced' => [
'<?php
trait T {
protected function foo() : void {}
public function bat() : void {
$this->foo();
}
}
class C {
use T;
protected function foo(string $s) : void {}
public function bat() : void {
$this->foo("bat");
}
}',
],
2018-03-21 22:39:01 +01:00
'aliasedPrivateMethodInternalCallWithLocalDefinition' => [
'<?php
trait T1 {
use T2;
private function foo() : int {
return $this->bar();
}
}
trait T2 {
private function bar() : int {
return 3;
}
}
class A {
use T1;
private function baz() : int {
return $this->bar();
}
}',
],
2018-05-09 04:32:57 +02:00
'traitClassConst' => [
'<?php
trait A {
public function foo(): string {
return B::class;
}
}
trait B {}
class C {
use A;
2019-03-23 19:27:54 +01:00
}',
2018-05-09 04:32:57 +02:00
],
'noRedundantConditionForTraitStatic' => [
'<?php
trait Foo {
public function bar() : array {
$type = static::class;
$r = new \ReflectionClass($type);
$values = $r->getConstants();
$callback =
/** @param mixed $v */
function ($v) : bool {
return \is_int($v) || \is_string($v);
};
if (is_a($type, \Bat::class, true)) {
$callback =
/** @param mixed $v */
function ($v) : bool {
return \is_int($v) && 0 === ($v & $v - 1) && $v > 0;
};
}
return array_filter($values, $callback);
}
}
class Bar {
use Foo;
}
class Bat {
use Foo;
2019-03-23 19:27:54 +01:00
}',
],
'nonMemoizedAssertions' => [
'<?php
trait T {
public function compare(O $other) : void {
if ($other instanceof self) {
if ($other->value === $this->value) {}
}
}
}
class O {}
class A extends O {
use T;
/** @var string */
private $value;
public function __construct(string $string) {
$this->value = $string;
}
}
class B extends O {
use T;
/** @var bool */
private $value;
public function __construct(bool $bool) {
$this->value = $bool;
}
2019-03-23 19:27:54 +01:00
}',
],
'manyTraitAliases' => [
'<?php
trait Foo {
public static function staticMethod():void {}
public function nonstatic():void {}
}
Class Bar {
use Foo {
Foo::staticMethod as foo;
Foo::staticMethod as foobar;
Foo::staticMethod as fine;
Foo::nonstatic as bad;
Foo::nonstatic as good;
}
}
$b = new Bar();
Bar::fine();
$b::fine();
$b->fine();
$b->good();
Bar::foo();
Bar::foobar();
$b::foo();
$b::foobar();
$b->foo();
$b->foobar();
2019-03-23 19:27:54 +01:00
$b->bad();',
],
'inheritedProtectedTraitMethodAccess' => [
'<?php
trait T {
private function bar() : void {}
}
class A {
use T {
bar as protected;
}
}
class AChild extends A {
public function foo() : void {
$this->bar();
}
2019-03-23 19:27:54 +01:00
}',
],
'inheritedPublicTraitMethodAccess' => [
'<?php
trait T {
private function bar() : void {}
}
class A {
use T {
bar as public;
}
}
2019-03-23 19:27:54 +01:00
(new A)->bar();',
],
'allowImplementMethodMadePublicInClass' => [
'<?php
interface I {
public function boo() : void;
}
trait T {
private function boo() : void {}
}
class A implements I {
use T { boo as public; }
}',
],
'allowImplementMethodMadePublicInParent' => [
'<?php
interface I {
public function boo() : void;
}
trait T {
private function boo() : void {}
}
class B {
use T { boo as public; }
}
class BChild extends B implements I {}',
],
'allowTraitParentDefinition' => [
'<?php
class A {}
class C extends A
{
use T;
}
trait T
{
public function bar() : ?C
{
if ($this instanceof A) {
return $this;
}
return null;
}
2019-03-23 19:27:54 +01:00
}',
],
'noCrashOnUndefinedIgnoredTrait' => [
'<?php
/** @psalm-suppress UndefinedTrait */
class C {
use UnknownTrait;
2019-03-23 19:27:54 +01:00
}',
],
'reconcileStaticTraitProperties' => [
'<?php
trait T {
/**
* @var string|null
*/
private static $b;
private static function booA(): string {
if (self::$b === null) {
return "hello";
}
return self::$b;
}
}
class C {
use T;
}',
],
'covariantAbstractReturn' => [
'<?php
trait T {
/** @return iterable */
abstract public function bar();
}
class C {
use T;
/** @return array */
public function bar() { return []; }
2019-03-23 19:27:54 +01:00
}',
],
'traitSelfParam' => [
'<?php
trait T {
public function bar(self $object): self {
return $this;
}
}
class Foo {
use T;
}
$f1 = new Foo();
$f2 = (new Foo())->bar($f1);',
],
'traitSelfDocblockReturn' => [
'<?php
trait T {
/** @return self */
public function getSelf() {
return $this;
}
}
class C {
use T;
2019-07-05 22:24:00 +02:00
}',
],
'abstractThisMethod' => [
'<?php
trait ATrait {
/** @return $this */
abstract public function bar();
}
class C {
use ATrait;
/** @return $this */
public function bar() {
return $this;
}
}'
],
'classAliasedTrait' => [
'<?php
trait FeatureV1 {}
class_alias(FeatureV1::class, Feature::class);
class Application {
use Feature;
}',
],
'renameMethodNoCrash' => [
'<?php
trait HelloTrait {
protected function sayHello() : string {
return "Hello";
}
}
class Person {
use HelloTrait {
2020-04-28 15:17:31 +02:00
sayHello as originalSayHello;
}
protected function sayHello() : string {
2020-04-28 15:17:31 +02:00
return $this->originalSayHello();
}
}
class BrokenPerson extends Person {
2020-04-28 15:17:31 +02:00
protected function originalSayHello() : string {
return "bad";
}
}',
],
'instanceofStaticInsideTrait' => [
'<?php
trait T {
/**
* @param mixed $instance
* @return ?static
*/
public static function filterInstance($instance) {
return $instance instanceof static ? $instance : null;
}
}
class A {
use T;
}'
],
'propertyNotDefinedInTrait' => [
'<?php
class A1 {
use A2;
public static string $titlefield = "blah";
}
trait A2 {
public static function test() : string {
/**
* @var string
*/
$sortfield = (isset(static::$sortfield)) ?
static::$sortfield
: static::$titlefield;
return $sortfield;
}
}'
],
'staticNotBoundInFinal' => [
'<?php
trait Foo {
/**
* @return static
*/
final public function foo(): self
{
return $this;
}
}
class A {
use Foo;
}'
],
'staticReturnWithFinal' => [
'<?php
trait T {
/** @return static */
public function instance() {
return new static();
}
}
final class A {
use T;
}'
],
];
2016-12-17 04:16:29 +01:00
}
2017-01-13 20:07:23 +01:00
/**
* @return iterable<string,array{string,error_message:string,1?:string[],2?:bool,3?:string}>
2017-01-13 20:07:23 +01:00
*/
public function providerInvalidCodeParse(): iterable
2016-12-17 04:16:29 +01:00
{
return [
'inaccessiblePrivateMethodFromInheritedTrait' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
private function fooFoo(): void {
}
}
class B {
use T;
}
class C extends B {
2018-01-11 21:50:45 +01:00
public function doFoo(): void {
$this->fooFoo();
}
}',
2017-05-27 02:05:57 +02:00
'error_message' => 'InaccessibleMethod',
],
'undefinedTrait' => [
'<?php
class B {
use A;
}',
2017-05-27 02:05:57 +02:00
'error_message' => 'UndefinedTrait',
],
'missingPropertyType' => [
'<?php
trait T {
public $foo = null;
}
class A {
use T;
2018-01-11 21:50:45 +01:00
public function assignToFoo(): void {
$this->foo = 5;
}
}',
2019-02-27 22:00:44 +01:00
'error_message' => 'MissingPropertyType - src' . DIRECTORY_SEPARATOR . 'somefile.php:3:32 - Property T::$foo does not have a ' .
'declared type - consider int|null',
],
'missingPropertyTypeWithConstructorInit' => [
'<?php
trait T {
public $foo;
}
class A {
use T;
2018-04-21 23:20:21 +02:00
public function __construct() {
$this->foo = 5;
}
}',
2019-02-27 22:00:44 +01:00
'error_message' => 'MissingPropertyType - src' . DIRECTORY_SEPARATOR . 'somefile.php:3:32 - Property T::$foo does not have a ' .
2017-05-27 02:05:57 +02:00
'declared type - consider int',
],
'missingPropertyTypeWithConstructorInitAndNull' => [
'<?php
trait T {
public $foo;
}
class A {
use T;
2018-04-21 23:20:21 +02:00
public function __construct() {
$this->foo = 5;
}
2018-01-11 21:50:45 +01:00
public function makeNull(): void {
$this->foo = null;
}
}',
2019-02-27 22:00:44 +01:00
'error_message' => 'MissingPropertyType - src' . DIRECTORY_SEPARATOR . 'somefile.php:3:32 - Property T::$foo does not have a ' .
'declared type - consider int|null',
],
'missingPropertyTypeWithConstructorInitAndNullDefault' => [
'<?php
trait T {
public $foo = null;
}
class A {
use T;
2018-04-21 23:20:21 +02:00
public function __construct() {
$this->foo = 5;
}
}',
2019-02-27 22:00:44 +01:00
'error_message' => 'MissingPropertyType - src' . DIRECTORY_SEPARATOR . 'somefile.php:3:32 - Property T::$foo does not have a ' .
'declared type - consider int|null',
2017-05-27 02:05:57 +02:00
],
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
'redefinedTraitMethodInSubclass' => [
'<?php
trait T {
2018-01-11 21:50:45 +01:00
public function fooFoo(): void {
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
}
}
class B {
use T;
}
class C extends B {
2018-01-11 21:50:45 +01:00
public function fooFoo(string $a): void {
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
}
}',
'error_message' => 'MethodSignatureMismatch',
],
'missingTraitPropertyType' => [
'<?php
trait T {
public $foo = 5;
}
class A {
use T;
}',
'error_message' => 'MissingPropertyType',
],
'nestedTraitWithBadReturnType' => [
'<?php
trait A {
public function foo() : string {
return 5;
}
}
trait B {
use A;
}
class C {
use B;
}',
'error_message' => 'InvalidReturnType',
],
'replaceTraitMethod' => [
'<?php
trait T {
protected function foo() : void {}
public function bat() : void {
$this->foo();
}
}
class C {
use T;
protected function foo(string $s) : void {}
}',
'error_message' => 'TooFewArguments',
],
'traitMethodMadePrivate' => [
'<?php
trait T {
public function foo() : void {
echo "here";
}
}
class C {
use T {
foo as private traitFoo;
}
public function bar() : void {
$this->traitFoo();
}
}
class D extends C {
public function bar() : void {
$this->traitFoo(); // should fail
}
}',
2019-03-23 19:27:54 +01:00
'error_message' => 'InaccessibleMethod',
],
'preventTraitPropertyType' => [
'<?php
trait T {}
class X {
/** @var T|null */
public $hm;
}',
'error_message' => 'UndefinedDocblockClass',
],
];
}
2016-12-17 04:16:29 +01:00
}