mirror of
https://github.com/danog/psalm.git
synced 2024-11-27 04:45:20 +01:00
776 lines
24 KiB
PHP
776 lines
24 KiB
PHP
<?php
|
|
|
|
namespace Psalm\Tests\FileManipulation;
|
|
|
|
use Psalm\Context;
|
|
use Psalm\Internal\Analyzer\ProjectAnalyzer;
|
|
use Psalm\Internal\Provider\FakeFileProvider;
|
|
use Psalm\Internal\Provider\Providers;
|
|
use Psalm\Internal\RuntimeCaches;
|
|
use Psalm\Tests\Internal\Provider\FakeParserCacheProvider;
|
|
use Psalm\Tests\TestCase;
|
|
use Psalm\Tests\TestConfig;
|
|
|
|
use function strpos;
|
|
|
|
class ClassMoveTest extends TestCase
|
|
{
|
|
protected ProjectAnalyzer $project_analyzer;
|
|
|
|
public function setUp(): void
|
|
{
|
|
RuntimeCaches::clearAll();
|
|
|
|
$this->file_provider = new FakeFileProvider();
|
|
}
|
|
|
|
/**
|
|
* @dataProvider providerValidCodeParse
|
|
* @param array<string, string> $constants_to_move
|
|
*/
|
|
public function testValidCode(
|
|
string $input_code,
|
|
string $output_code,
|
|
array $constants_to_move
|
|
): void {
|
|
$test_name = $this->getTestName();
|
|
if (strpos($test_name, 'SKIPPED-') !== false) {
|
|
$this->markTestSkipped('Skipped due to a bug.');
|
|
}
|
|
|
|
$config = new TestConfig();
|
|
|
|
$this->project_analyzer = new ProjectAnalyzer(
|
|
$config,
|
|
new Providers(
|
|
$this->file_provider,
|
|
new FakeParserCacheProvider(),
|
|
),
|
|
);
|
|
|
|
$context = new Context();
|
|
|
|
$file_path = self::$src_dir_path . 'somefile.php';
|
|
|
|
$this->addFile(
|
|
$file_path,
|
|
$input_code,
|
|
);
|
|
|
|
$codebase = $this->project_analyzer->getCodebase();
|
|
|
|
$this->project_analyzer->refactorCodeAfterCompletion($constants_to_move);
|
|
|
|
$this->analyzeFile($file_path, $context);
|
|
|
|
$this->project_analyzer->prepareMigration();
|
|
|
|
$codebase->analyzer->updateFile($file_path, false);
|
|
|
|
$this->project_analyzer->migrateCode();
|
|
|
|
$this->assertSame($output_code, $codebase->getFileContents($file_path));
|
|
}
|
|
|
|
/**
|
|
* @return array<string,array{input:string,output:string,migrations:array<string, string>}>
|
|
*/
|
|
public function providerValidCodeParse(): array
|
|
{
|
|
return [
|
|
'renameEmptyClass' => [
|
|
'input' => '<?php
|
|
namespace Ns;
|
|
|
|
class A {}
|
|
|
|
class C extends A {
|
|
/**
|
|
* @var A
|
|
*/
|
|
public $one;
|
|
}
|
|
|
|
/**
|
|
* @param A $a
|
|
* @param A::class|C::class $b
|
|
* @return A
|
|
*/
|
|
function foo(A $a, string $b) : A {
|
|
return $a;
|
|
}
|
|
|
|
/** @var A */
|
|
$i = new A();
|
|
|
|
if ($i instanceof A) {}',
|
|
'output' => '<?php
|
|
namespace Ns;
|
|
|
|
class B {}
|
|
|
|
class C extends B {
|
|
/**
|
|
* @var B
|
|
*/
|
|
public $one;
|
|
}
|
|
|
|
/**
|
|
* @param B $a
|
|
* @param B::class|C::class $b
|
|
* @return B
|
|
*/
|
|
function foo(B $a, string $b) : B {
|
|
return $a;
|
|
}
|
|
|
|
/** @var B */
|
|
$i = new B();
|
|
|
|
if ($i instanceof B) {}',
|
|
'migrations' => [
|
|
'Ns\A' => 'Ns\B',
|
|
],
|
|
],
|
|
'renameEmptyClassWithSpacesInDocblock' => [
|
|
'input' => '<?php
|
|
namespace Ns;
|
|
|
|
class A {}
|
|
|
|
/**
|
|
* @param ?A $a
|
|
* @param string | null $b
|
|
* @param callable(): A $c
|
|
* @return A | null
|
|
*/
|
|
function foo(?A $a, $b, $c) : ?A {
|
|
return $a;
|
|
}',
|
|
'output' => '<?php
|
|
namespace Ns;
|
|
|
|
class B {}
|
|
|
|
/**
|
|
* @param B|null $a
|
|
* @param string | null $b
|
|
* @param callable():B $c
|
|
* @return B|null
|
|
*/
|
|
function foo(?B $a, $b, $c) : ?B {
|
|
return $a;
|
|
}',
|
|
'migrations' => [
|
|
'Ns\A' => 'Ns\B',
|
|
],
|
|
],
|
|
'renameClassWithInstanceMethod' => [
|
|
'input' => '<?php
|
|
namespace Ns;
|
|
|
|
class A {
|
|
/**
|
|
* @param self $one
|
|
* @param A $two
|
|
*/
|
|
public function foo(self $one, A $two) : void {}
|
|
}
|
|
|
|
function foo(A $a) : A {
|
|
return $a->foo($a, $a);
|
|
}',
|
|
'output' => '<?php
|
|
namespace Ns;
|
|
|
|
class B {
|
|
/**
|
|
* @param self $one
|
|
* @param self $two
|
|
*/
|
|
public function foo(self $one, self $two) : void {}
|
|
}
|
|
|
|
function foo(B $a) : B {
|
|
return $a->foo($a, $a);
|
|
}',
|
|
'migrations' => [
|
|
'Ns\A' => 'Ns\B',
|
|
],
|
|
],
|
|
'renameClassWithStaticMethod' => [
|
|
'input' => '<?php
|
|
namespace Ns;
|
|
|
|
class AParent {
|
|
public static function foo(A $one, A $two) {
|
|
|
|
}
|
|
}
|
|
|
|
class A extends AParent {
|
|
/**
|
|
* @param self $one
|
|
* @param A $two
|
|
* @return static
|
|
*/
|
|
public static function foo(self $one, A $two) : void {
|
|
A::foo($one, $two);
|
|
self::foo($one, $two);
|
|
parent::foo($one, $two);
|
|
static::foo($one, $two);
|
|
return new static();
|
|
}
|
|
}
|
|
|
|
$a = A::class;
|
|
|
|
$a::foo(new A(), new A());
|
|
|
|
function foo() {
|
|
A::foo(new A(), A::foo());
|
|
}',
|
|
'output' => '<?php
|
|
namespace Ns;
|
|
|
|
class AParent {
|
|
public static function foo(B $one, B $two) {
|
|
|
|
}
|
|
}
|
|
|
|
class B extends AParent {
|
|
/**
|
|
* @param self $one
|
|
* @param self $two
|
|
* @return static
|
|
*/
|
|
public static function foo(self $one, self $two) : void {
|
|
B::foo($one, $two);
|
|
self::foo($one, $two);
|
|
parent::foo($one, $two);
|
|
static::foo($one, $two);
|
|
return new static();
|
|
}
|
|
}
|
|
|
|
$a = B::class;
|
|
|
|
$a::foo(new B(), new B());
|
|
|
|
function foo() {
|
|
B::foo(new B(), B::foo());
|
|
}',
|
|
'migrations' => [
|
|
'Ns\A' => 'Ns\B',
|
|
],
|
|
],
|
|
'renameClassWithInstanceProperty' => [
|
|
'input' => '<?php
|
|
namespace Ns;
|
|
|
|
class A {
|
|
/**
|
|
* @var A
|
|
*/
|
|
public $one;
|
|
|
|
/**
|
|
* @var self
|
|
*/
|
|
public $two;
|
|
}',
|
|
'output' => '<?php
|
|
namespace Ns;
|
|
|
|
class B {
|
|
/**
|
|
* @var self
|
|
*/
|
|
public $one;
|
|
|
|
/**
|
|
* @var self
|
|
*/
|
|
public $two;
|
|
}',
|
|
'migrations' => [
|
|
'Ns\A' => 'Ns\B',
|
|
],
|
|
],
|
|
'renameClassWithStaticProperty' => [
|
|
'input' => '<?php
|
|
namespace Ns;
|
|
|
|
class A {
|
|
/**
|
|
* @var string
|
|
*/
|
|
public static $one = "one";
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
public static $vars = ["one"];
|
|
}
|
|
|
|
echo A::$one;
|
|
A::$one = "two";
|
|
|
|
foreach (A::$vars as $var) {}',
|
|
'output' => '<?php
|
|
namespace Ns;
|
|
|
|
class B {
|
|
/**
|
|
* @var string
|
|
*/
|
|
public static $one = "one";
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
public static $vars = ["one"];
|
|
}
|
|
|
|
echo B::$one;
|
|
B::$one = "two";
|
|
|
|
foreach (B::$vars as $var) {}',
|
|
'migrations' => [
|
|
'Ns\A' => 'Ns\B',
|
|
],
|
|
],
|
|
'moveClassIntoNamespace' => [
|
|
'input' => '<?php
|
|
use Exception;
|
|
|
|
class A {
|
|
/** @var ?Exception */
|
|
public $x;
|
|
|
|
/**
|
|
* @param ArrayObject<int, A> $a
|
|
* @throws RunTimeException
|
|
*/
|
|
public function foo(ArrayObject $a) : Exception {
|
|
foreach ($a as $b) {
|
|
$b->bar();
|
|
}
|
|
|
|
try {
|
|
// something
|
|
} catch (InvalidArgumentException $e) {
|
|
|
|
}
|
|
|
|
echo \A::class;
|
|
echo __CLASS__;
|
|
echo self::class;
|
|
|
|
ArrayObject::foo();
|
|
|
|
return new Exception("bad");
|
|
}
|
|
|
|
public function bar() : void {}
|
|
}',
|
|
'output' => '<?php
|
|
namespace Foo\Bar\Baz;
|
|
|
|
use Exception;
|
|
|
|
class B {
|
|
/** @var Exception|null */
|
|
public $x;
|
|
|
|
/**
|
|
* @param \ArrayObject<int, self> $a
|
|
* @throws \RunTimeException
|
|
*/
|
|
public function foo(\ArrayObject $a) : Exception {
|
|
foreach ($a as $b) {
|
|
$b->bar();
|
|
}
|
|
|
|
try {
|
|
// something
|
|
} catch (\InvalidArgumentException $e) {
|
|
|
|
}
|
|
|
|
echo B::class;
|
|
echo B::class;
|
|
echo self::class;
|
|
|
|
\ArrayObject::foo();
|
|
|
|
return new Exception("bad");
|
|
}
|
|
|
|
public function bar() : void {}
|
|
}',
|
|
'migrations' => [
|
|
'A' => 'Foo\Bar\Baz\B',
|
|
],
|
|
],
|
|
'moveClassDeeperIntoNamespaceAdjustUseWithoutAlias' => [
|
|
'input' => '<?php
|
|
namespace Foo {
|
|
use Bar\Bat;
|
|
|
|
echo Bat::FOO;
|
|
echo Bat::FAR;
|
|
|
|
/**
|
|
* @param Bat $b
|
|
* @param Bat::FOO|Bat::FAR $c
|
|
*/
|
|
function doSomething(Bat $b, int $c) : void {}
|
|
|
|
class A {
|
|
/** @var ?Bat */
|
|
public $x = null;
|
|
}
|
|
}
|
|
namespace Bar {
|
|
class Bat {
|
|
const FOO = 5;
|
|
const FAR = 7;
|
|
}
|
|
}',
|
|
'output' => '<?php
|
|
namespace Foo {
|
|
use Bar\Baz\Bahh;
|
|
|
|
echo Bahh::FOO;
|
|
echo Bahh::FAR;
|
|
|
|
/**
|
|
* @param Bahh $b
|
|
* @param Bahh::FAR|Bahh::FOO $c
|
|
*/
|
|
function doSomething(Bahh $b, int $c) : void {}
|
|
|
|
class A {
|
|
/** @var Bahh|null */
|
|
public $x = null;
|
|
}
|
|
}
|
|
namespace Bar\Baz {
|
|
class Bahh {
|
|
const FOO = 5;
|
|
const FAR = 7;
|
|
}
|
|
}',
|
|
'migrations' => [
|
|
'Bar\Bat' => 'Bar\Baz\Bahh',
|
|
],
|
|
],
|
|
'moveClassesIntoNamespace' => [
|
|
'input' => '<?php
|
|
namespace Foo {
|
|
class A {
|
|
/** @var ?B */
|
|
public $x = null;
|
|
/** @var ?A */
|
|
public $y = null;
|
|
/** @var A|B|C|null */
|
|
public $z = null;
|
|
}
|
|
}
|
|
|
|
namespace Foo {
|
|
class B {
|
|
/** @var ?A */
|
|
public $x = null;
|
|
/** @var ?B */
|
|
public $y = null;
|
|
/** @var A|B|C|null */
|
|
public $z = null;
|
|
}
|
|
}
|
|
|
|
namespace Bar {
|
|
use Foo\A;
|
|
use Foo\B;
|
|
|
|
class C {
|
|
/** @var ?A */
|
|
public $x = null;
|
|
/** @var ?B */
|
|
public $y = null;
|
|
/** @var A|B|null */
|
|
public $z = null;
|
|
}
|
|
}',
|
|
'output' => '<?php
|
|
namespace Bar\Baz {
|
|
class A {
|
|
/** @var B|null */
|
|
public $x = null;
|
|
/** @var null|self */
|
|
public $y = null;
|
|
/** @var B|\Foo\C|null|self */
|
|
public $z = null;
|
|
}
|
|
}
|
|
|
|
namespace Bar\Baz {
|
|
class B {
|
|
/** @var A|null */
|
|
public $x = null;
|
|
/** @var null|self */
|
|
public $y = null;
|
|
/** @var A|\Foo\C|null|self */
|
|
public $z = null;
|
|
}
|
|
}
|
|
|
|
namespace Bar {
|
|
use Bar\Baz\A;
|
|
use Bar\Baz\B;
|
|
|
|
class C {
|
|
/** @var A|null */
|
|
public $x = null;
|
|
/** @var B|null */
|
|
public $y = null;
|
|
/** @var A|B|null */
|
|
public $z = null;
|
|
}
|
|
}',
|
|
'migrations' => [
|
|
'Foo\A' => 'Bar\Baz\A',
|
|
'Foo\B' => 'Bar\Baz\B',
|
|
],
|
|
],
|
|
'moveClassesIntoNamespaceWithoutAlias' => [
|
|
'input' => '<?php
|
|
namespace Foo {
|
|
class A {
|
|
/** @var ?B */
|
|
public $x = null;
|
|
/** @var ?A */
|
|
public $y = null;
|
|
/** @var A|B|C|null */
|
|
public $z = null;
|
|
|
|
public static $vars = [1, 2, 3];
|
|
}
|
|
}
|
|
|
|
namespace Foo {
|
|
class B {
|
|
/** @var ?A */
|
|
public $x = null;
|
|
/** @var ?B */
|
|
public $y = null;
|
|
/** @var A|B|C|null */
|
|
public $z = null;
|
|
}
|
|
|
|
foreach (A::$vars[$foo] as $var) {}
|
|
}
|
|
|
|
namespace Bar {
|
|
class C {
|
|
/** @var ?\Foo\A */
|
|
public $x = null;
|
|
/** @var ?\Foo\B */
|
|
public $y = null;
|
|
/** @var \Foo\A|\Foo\B|null */
|
|
public $z = null;
|
|
}
|
|
|
|
foreach (\Foo\A::$vars as $var) {}
|
|
}',
|
|
'output' => '<?php
|
|
namespace Bar\Baz {
|
|
class A {
|
|
/** @var B|null */
|
|
public $x = null;
|
|
/** @var null|self */
|
|
public $y = null;
|
|
/** @var B|\Foo\C|null|self */
|
|
public $z = null;
|
|
|
|
public static $vars = [1, 2, 3];
|
|
}
|
|
}
|
|
|
|
namespace Bar\Baz {
|
|
class B {
|
|
/** @var A|null */
|
|
public $x = null;
|
|
/** @var null|self */
|
|
public $y = null;
|
|
/** @var A|\Foo\C|null|self */
|
|
public $z = null;
|
|
}
|
|
|
|
foreach (\Bar\Baz\A::$vars[$foo] as $var) {}
|
|
}
|
|
|
|
namespace Bar {
|
|
class C {
|
|
/** @var Baz\A|null */
|
|
public $x = null;
|
|
/** @var Baz\B|null */
|
|
public $y = null;
|
|
/** @var Baz\A|Baz\B|null */
|
|
public $z = null;
|
|
}
|
|
|
|
foreach (Baz\A::$vars as $var) {}
|
|
}',
|
|
'migrations' => [
|
|
'Foo\A' => 'Bar\Baz\A',
|
|
'Foo\B' => 'Bar\Baz\B',
|
|
],
|
|
],
|
|
'moveClassDeeperIntoNamespaceAdjustUseWithAlias' => [
|
|
'input' => '<?php
|
|
namespace Foo {
|
|
use Bar\Bat as Kappa;
|
|
|
|
echo Kappa::FOO;
|
|
echo Kappa::FAR;
|
|
|
|
/**
|
|
* @param Kappa $b
|
|
* @param Kappa::FOO|Kappa::FAR $c
|
|
*/
|
|
function doSomething(Kappa $b, int $c) : void {}
|
|
|
|
class A {
|
|
/** @var ?Kappa */
|
|
public $x = null;
|
|
}
|
|
}
|
|
namespace Bar {
|
|
class Bat {
|
|
const FOO = 5;
|
|
const FAR = 7;
|
|
}
|
|
}',
|
|
'output' => '<?php
|
|
namespace Foo {
|
|
use Bar\Baz\Bahh as Kappa;
|
|
|
|
echo Kappa::FOO;
|
|
echo Kappa::FAR;
|
|
|
|
/**
|
|
* @param Kappa $b
|
|
* @param Kappa::FAR|Kappa::FOO $c
|
|
*/
|
|
function doSomething(Kappa $b, int $c) : void {}
|
|
|
|
class A {
|
|
/** @var Kappa|null */
|
|
public $x = null;
|
|
}
|
|
}
|
|
namespace Bar\Baz {
|
|
class Bahh {
|
|
const FOO = 5;
|
|
const FAR = 7;
|
|
}
|
|
}',
|
|
'migrations' => [
|
|
'Bar\Bat' => 'Bar\Baz\Bahh',
|
|
],
|
|
],
|
|
'moveClassDeeperIntoNamespaceDontAdjustGroupUse' => [
|
|
'input' => '<?php
|
|
namespace Foo {
|
|
use Bar\{Bat};
|
|
|
|
/**
|
|
* @param Bat $b
|
|
*/
|
|
function doSomething(Bat $b) : void {}
|
|
}
|
|
namespace Bar {
|
|
class Bat {}
|
|
}',
|
|
'output' => '<?php
|
|
namespace Foo {
|
|
use Bar\{Bat};
|
|
|
|
/**
|
|
* @param \Bar\Baz\Bahh $b
|
|
*/
|
|
function doSomething(\Bar\Baz\Bahh $b) : void {}
|
|
}
|
|
namespace Bar\Baz {
|
|
class Bahh {}
|
|
}',
|
|
'migrations' => [
|
|
'Bar\Bat' => 'Bar\Baz\Bahh',
|
|
],
|
|
],
|
|
'moveClassBewareOfPropertyNotSetInConstructorCheck' => [
|
|
'input' => '<?php
|
|
namespace Foo {
|
|
class Base
|
|
{
|
|
protected $property1;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->property1 = "";
|
|
}
|
|
}
|
|
}
|
|
namespace Foo {
|
|
class Hello extends Base {}
|
|
}',
|
|
'output' => '<?php
|
|
namespace Foo {
|
|
class Base
|
|
{
|
|
protected $property1;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->property1 = "";
|
|
}
|
|
}
|
|
}
|
|
namespace Foo\Bar {
|
|
class Hello extends \Foo\Base {}
|
|
}',
|
|
'migrations' => [
|
|
'Foo\Hello' => 'Foo\Bar\Hello',
|
|
],
|
|
],
|
|
'renamesAllStaticPropReferences' => [
|
|
'input' => '<?php
|
|
namespace Foo;
|
|
|
|
class Bar {
|
|
public static $props = [1, 2, 3];
|
|
}
|
|
echo Bar::$props[1];
|
|
echo Bar::$props[2];
|
|
',
|
|
'output' => '<?php
|
|
namespace Zoo;
|
|
|
|
class Baz {
|
|
public static $props = [1, 2, 3];
|
|
}
|
|
echo \Zoo\Baz::$props[1];
|
|
echo \Zoo\Baz::$props[2];
|
|
',
|
|
'migrations' => [
|
|
'Foo\Bar' => 'Zoo\Baz',
|
|
],
|
|
],
|
|
];
|
|
}
|
|
}
|