1
0
mirror of https://github.com/danog/psalm.git synced 2024-12-13 01:37:23 +01:00
psalm/tests/FileManipulation/MethodMoveTest.php
Matthew Brown 8d36bdc3ed
Make array shapes strict by default (#8701)
* Make array shapes strict by default

* Fix PSL tests
2022-11-11 20:14:21 -05:00

787 lines
23 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 MethodMoveTest extends TestCase
{
/** @var ProjectAnalyzer */
protected $project_analyzer;
public function setUp(): void
{
RuntimeCaches::clearAll();
$this->file_provider = new FakeFileProvider();
}
/**
* @dataProvider providerValidCodeParse
*
* @param array<string, string> $methods_to_move
*/
public function testValidCode(
string $input_code,
string $output_code,
array $methods_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($methods_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 [
'moveSimpleStaticMethodWithForeachIterator' => [
'input' => '<?php
namespace Ns;
use ArrayObject;
A::Foo();
class A {
/**
* @return ArrayObject<int, int>
*/
public static function Foo() {
return new ArrayObject([1, 2, 3]);
}
}
class B {
public static function bar() : void {
A::Foo();
foreach (A::Foo() as $f) {}
}
}',
'output' => '<?php
namespace Ns;
use ArrayObject;
B::Fe();
class A {
}
class B {
public static function bar() : void {
B::Fe();
foreach (B::Fe() as $f) {}
}
/**
* @return ArrayObject<int, int>
*/
public static function Fe() {
return new ArrayObject([1, 2, 3]);
}
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\B::Fe',
],
],
'moveSimpleStaticMethodWithConstant' => [
'input' => '<?php
namespace Ns;
class A {
const C = 5;
public static function Foo() : void {
echo self::C;
}
}
class B {
}',
'output' => '<?php
namespace Ns;
class A {
const C = 5;
}
class B {
public static function Fe() : void {
echo A::C;
}
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\B::Fe',
],
],
'moveSimpleStaticMethodWithProperty' => [
'input' => '<?php
namespace Ns;
class A {
/** @var int */
public static $baz;
public static function Foo() : void {
echo self::$baz;
echo A::$baz . " ";
self::$baz = 12;
A::$baz = 14;
}
}
class B {
}',
'output' => '<?php
namespace Ns;
class A {
/** @var int */
public static $baz;
}
class B {
public static function Fe() : void {
echo A::$baz;
echo A::$baz . " ";
A::$baz = 12;
A::$baz = 14;
}
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\B::Fe',
],
],
'moveStaticMethodIntoNamespaceWithExistingUse' => [
'input' => '<?php
namespace {
class A {
public static function Foo() : void {}
}
}
namespace Ns {
use A;
class C {
public static function Bar() : void {
A::Foo();
}
}
}
namespace Ns\A {
class B {
}
}',
'output' => '<?php
namespace {
class A {
}
}
namespace Ns {
use A;
class C {
public static function Bar() : void {
\Ns\A\B::Fedcba();
}
}
}
namespace Ns\A {
class B {
public static function Fedcba() : void {}
}
}',
'migrations' => [
'A::Foo' => 'Ns\A\B::Fedcba',
],
],
'moveEmptyStaticMethodOnly' => [
'input' => '<?php
namespace Ns;
class A {
/**
* @return void
*/
public static function Foo() : void {}
}
class B {
}',
'output' => '<?php
namespace Ns;
class A {
}
class B {
/**
* @return void
*/
public static function Fedcba() : void {}
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\B::Fedcba',
],
],
'moveStaticMethodOnly' => [
'input' => '<?php
namespace Ns;
class A {
const C = 5;
/**
* @param self $a1
* Some description
* @param ?self
* $a2
* @param array<
* int,
* self
* > $a3
* @return self
*/
public static function Foo(self $a1, ?self $a2, array $a3) : self {
echo self::C;
echo A::C;
self::Bar();
A::Bar();
echo \Ns\B::D;
new A();
/** @var self */
$a = new self();
new B();
return $a;
}
public static function Bar() : void {}
}
class B {
const D = 5;
}',
'output' => '<?php
namespace Ns;
class A {
const C = 5;
public static function Bar() : void {}
}
class B {
const D = 5;
/**
* @param A $a1
* Some description
* @param A|null
* $a2
* @param array<int, A> $a3
* @return A
*/
public static function Fedbca(A $a1, ?A $a2, array $a3) : A {
echo A::C;
echo A::C;
A::Bar();
A::Bar();
echo B::D;
new A();
/** @var A */
$a = new A();
new B();
return $a;
}
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\B::Fedbca',
],
],
'moveTwoStaticMethods' => [
'input' => '<?php
namespace Ns;
class A {
const C = 5;
/**
* @param self $a1
* Some description
* @param ?self
* $a2
* @param array<
* int,
* self
* > $a3
* @return self
*/
public static function Foo(self $a1, ?self $a2, array $a3) : self {
echo self::C;
echo A::C;
self::Bar();
A::Bar();
echo \Ns\B::D;
new A();
/** @var self */
$a = new self();
new B();
return $a;
}
public static function Bar() : void {}
}
class B {
const D = 5;
}',
'output' => '<?php
namespace Ns;
class A {
const C = 5;
}
class B {
const D = 5;
/**
* @param A $a1
* Some description
* @param A|null
* $a2
* @param array<int, A> $a3
* @return A
*/
public static function Fedbca(A $a1, ?A $a2, array $a3) : A {
echo A::C;
echo A::C;
self::Blacksheep();
B::Blacksheep();
echo B::D;
new A();
/** @var A */
$a = new A();
new B();
return $a;
}
public static function Blacksheep() : void {}
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\B::Fedbca',
'Ns\A::Bar' => 'Ns\B::Blacksheep',
],
],
'moveInstanceMethodIntoSubclassOnly' => [
'input' => '<?php
namespace Ns;
class A {
const C = 5;
/**
* @param self $a1
* Some description
* @param ?self
* $a2
* @param array<
* int,
* self
* > $a3
* @return self
*/
public function Foo(self $a1, ?self $a2, array $a3) : self {
echo self::C;
echo A::C;
$this->Bar();
A::Bar();
echo \Ns\AChild::D;
new A();
/** @var self */
$a = new self();
new AChild();
return $a;
}
public function Bar() : void {}
}
class AChild extends A {
const D = 5;
}',
'output' => '<?php
namespace Ns;
class A {
const C = 5;
public function Bar() : void {}
}
class AChild extends A {
const D = 5;
/**
* @param A $a1
* Some description
* @param A|null
* $a2
* @param array<int, A> $a3
* @return A
*/
public function Fedbca(A $a1, ?A $a2, array $a3) : A {
echo A::C;
echo A::C;
$this->Bar();
A::Bar();
echo AChild::D;
new A();
/** @var A */
$a = new A();
new AChild();
return $a;
}
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\AChild::Fedbca',
],
],
'moveStaticMethodAndReferencesFromAbove' => [
'input' => '<?php
namespace Ns;
class A {
const C = 5;
/**
* @return void
*/
public static function Foo() : void {
echo self::C;
}
}
class B {
public static function bar() : void {
A::Foo();
}
}',
'output' => '<?php
namespace Ns;
class A {
const C = 5;
}
class B {
public static function bar() : void {
B::Fe();
}
/**
* @return void
*/
public static function Fe() : void {
echo A::C;
}
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\B::Fe',
],
],
'moveStaticMethodAndReferencesFromBelow' => [
'input' => '<?php
namespace Ns;
class B {
public static function bar() : void {
A::Foo();
}
}
class A {
const C = 5;
/**
* @return void
*/
public static function Foo() : void {
echo self::C;
}
}',
'output' => '<?php
namespace Ns;
class B {
public static function bar() : void {
B::Fe();
}
/**
* @return void
*/
public static function Fe() : void {
echo A::C;
}
}
class A {
const C = 5;
}',
'migrations' => [
'Ns\A::Foo' => 'Ns\B::Fe',
],
],
'moveStaticMethodAndReferencesAcrossNamespaces' => [
'input' => '<?php
namespace Ns1 {
class A {
const C = 5;
/**
* @return void
*/
public static function Foo() : void {
echo self::C;
}
}
}
namespace Ns2\Ns3 {
class B {
public static function bar() : void {
\Ns1\A::Foo();
}
}
}',
'output' => '<?php
namespace Ns1 {
class A {
const C = 5;
}
}
namespace Ns2\Ns3 {
class B {
public static function bar() : void {
B::Fe();
}
/**
* @return void
*/
public static function Fe() : void {
echo \Ns1\A::C;
}
}
}',
'migrations' => [
'Ns1\A::Foo' => 'Ns2\Ns3\B::Fe',
],
],
'moveStaticMethodAndReferencesAcrossNamespacesWithExistingUse' => [
'input' => '<?php
namespace Ns1 {
class A {
const C = 5;
/**
* @return void
*/
public static function Foo() : void {
echo self::C;
}
}
}
namespace Ns2\Ns3 {
use Ns1\A;
class B {
public static function bar() : void {
\Ns1\A::Foo();
}
}
}',
'output' => '<?php
namespace Ns1 {
class A {
const C = 5;
}
}
namespace Ns2\Ns3 {
use Ns1\A;
class B {
public static function bar() : void {
B::Fedcba();
}
/**
* @return void
*/
public static function Fedcba() : void {
echo A::C;
}
}
}',
'migrations' => [
'Ns1\A::Foo' => 'Ns2\Ns3\B::Fedcba',
],
],
'renameInstanceMethod' => [
'input' => '<?php
namespace Ns;
use ArrayObject;
class A {
/**
* @return ArrayObject<int, int>
*/
public function Foo() {
return new ArrayObject([self::C]);
}
public function bat() {
$this->foo();
}
}
class B extends A {
public static function bar(A $a) : void {
$a->Foo();
$this->foo();
parent::foo();
foreach ($a->Foo() as $f) {}
}
}',
'output' => '<?php
namespace Ns;
use ArrayObject;
class A {
/**
* @return ArrayObject<int, int>
*/
public function Fedcba() {
return new ArrayObject([self::C]);
}
public function bat() {
$this->Fedcba();
}
}
class B extends A {
public static function bar(A $a) : void {
$a->Fedcba();
$this->Fedcba();
parent::Fedcba();
foreach ($a->Fedcba() as $f) {}
}
}',
'migrations' => [
'Ns\A::foo' => 'Ns\A::Fedcba',
],
],
];
}
}