Laravel 12 set with Bind Closures without Abstract rule

config/sets/laravel120.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use RectorLaravel\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector;
+
+// see https://laravel.com/docs/12.x/upgrade
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->import(__DIR__ . '/../config.php');
+
+    // https://github.com/laravel/framework/pull/54628
+    $rectorConfig->rule(ContainerBindConcreteWithClosureOnlyRector::class);
+};

config/sets/level/up-to-laravel-120.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use RectorLaravel\Set\LaravelLevelSetList;
+use RectorLaravel\Set\LaravelSetList;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->sets([LaravelSetList::LARAVEL_120, LaravelLevelSetList::UP_TO_LARAVEL_110]);
+};

src/Rector/MethodCall/ContainerBindConcreteWithClosureOnlyRector.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace RectorLaravel\Rector\MethodCall;
+
+use PhpParser\Node;
+use PhpParser\Node\Const_;
+use PhpParser\Node\Expr\Closure;
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
+use Rector\Rector\AbstractRector;
+use Rector\StaticTypeMapper\StaticTypeMapper;
+use Rector\TypeDeclaration\TypeInferer\ReturnTypeInferer;
+use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
+use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
+
+final class ContainerBindConcreteWithClosureOnlyRector extends AbstractRector
+{
+    public function __construct(
+        private readonly ReturnTypeInferer $returnTypeInferer,
+        private readonly StaticTypeMapper $staticTypeMapper,
+    ) {}
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition(
+            'Drop the specified abstract class from the bind method and replace it with a closure that returns the abstract class.',
+            [
+                new CodeSample(
+                    <<<'CODE_SAMPLE'
+$this->app->bind(SomeClass::class, function (): SomeClass {
+    return new SomeClass();
+});
+CODE_SAMPLE
+                    ,
+                    <<<'CODE_SAMPLE'
+$this->app->bind(function (): SomeClass {
+    return new SomeClass();
+});
+CODE_SAMPLE
+                ),
+            ]
+        );
+    }
+
+    public function getNodeTypes(): array
+    {
+        return [MethodCall::class];
+    }
+
+    /**
+     * @param  MethodCall  $node
+     */
+    public function refactor(Node $node): ?MethodCall
+    {
+        if (! $this->isNames($node->name, ['bind', 'singleton', 'bindIf', 'singletonIf'])) {
+            return null;
+        }
+
+        if (! $this->isObjectType($node->var, new ObjectType('Illuminate\Contracts\Container\Container'))) {
+            return null;
+        }
+
+        if ($node->isFirstClassCallable()) {
+            return null;
+        }
+
+        if (count($node->getArgs()) < 2) {
+            return null;
+        }
+
+        $type = $this->getType($node->getArgs()[0]->value);
+        $classString = $node->getArgs()[0]->value;
+        $concreteNode = $node->getArgs()[1]->value;
+
+        if (! $concreteNode instanceof Closure) {
+            return null;
+        }
+        $abstractFromConcrete = $this->returnTypeInferer->inferFunctionLike($concreteNode);
+
+        if ($classString instanceof Const_
+        && $this->isName($classString, 'class')) {
+            return null;
+        }
+
+        $abstractObjectType = $type->getClassStringObjectType();
+
+        if ($abstractFromConcrete->isSuperTypeOf($abstractObjectType)->no()) {
+            return null;
+        }
+
+        // set the concrete's return type of the closure to from what's determined in PHPStan
+        $returnTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($abstractObjectType, TypeKind::RETURN);
+        if (! $returnTypeNode instanceof Node) {
+            return null;
+        }
+
+        $concreteNode->returnType = $returnTypeNode;
+
+        $args = $node->getArgs();
+
+        $node->args = array_splice($args, 1);
+
+        return $node;
+    }
+}

src/Set/LaravelLevelSetList.php

@@ -33,4 +33,6 @@ final class LaravelLevelSetList
     final public const string UP_TO_LARAVEL_100 = __DIR__ . '/../../config/sets/level/up-to-laravel-100.php';
 
     final public const string UP_TO_LARAVEL_110 = __DIR__ . '/../../config/sets/level/up-to-laravel-110.php';
+
+    final public const string UP_TO_LARAVEL_120 = __DIR__ . '/../../config/sets/level/up-to-laravel-120.php';
 }

src/Set/LaravelSetList.php

@@ -38,6 +38,8 @@ final class LaravelSetList
 
     final public const string LARAVEL_110 = __DIR__ . '/../../config/sets/laravel110.php';
 
+    final public const string LARAVEL_120 = __DIR__ . '/../../config/sets/laravel120.php';
+
     final public const string LARAVEL_ARRAYACCESS_TO_METHOD_CALL = __DIR__ . '/../../config/sets/laravel-arrayaccess-to-method-call.php';
 
     final public const string LARAVEL_ARRAY_STR_FUNCTION_TO_STATIC_CALL = __DIR__ . '/../../config/sets/laravel-array-str-functions-to-static-call.php';

src/Set/LaravelSetProvider.php

@@ -30,6 +30,7 @@ final class LaravelSetProvider implements SetProviderInterface
      * @var string[]
      */
     private const array LARAVEL_POST_FIVE = [
+        LaravelSetList::LARAVEL_120,
         LaravelSetList::LARAVEL_110,
         LaravelSetList::LARAVEL_100,
         LaravelSetList::LARAVEL_90,

tests/Rector/MethodCall/ContainerBindConcreteWithClosureOnlyRector/ContainerBindConcreteWithClosureOnlyRectorTest.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class ContainerBindConcreteWithClosureOnlyRectorTest extends AbstractRectorTestCase
+{
+    public static function provideData(): Iterator
+    {
+        return self::yieldFilesFromDirectory(__DIR__ . '/Fixture');
+    }
+
+    /**
+     * @test
+     */
+    #[DataProvider('provideData')]
+    public function test(string $filePath): void
+    {
+        $this->doTestFile($filePath);
+    }
+
+    public function provideConfigFilePath(): string
+    {
+        return __DIR__ . '/config/configured_rule.php';
+    }
+}

tests/Rector/MethodCall/ContainerBindConcreteWithClosureOnlyRector/Fixture/fixture.php.inc

@@ -0,0 +1,45 @@
+<?php
+
+namespace RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Fixture;
+
+use Illuminate\Contracts\Container\Container;
+use RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source\SomeClass;
+use RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source\SomeInterface;
+
+/** @var Container $app */
+$app->bind(SomeInterface::class, function () {
+    return new SomeClass();
+});
+
+$app->bind(SomeInterface::class, function (): SomeClass {
+    return new SomeClass();
+});
+
+$app->singleton(SomeInterface::class, function () {
+    return new SomeClass();
+});
+
+?>
+-----
+<?php
+
+namespace RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Fixture;
+
+use Illuminate\Contracts\Container\Container;
+use RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source\SomeClass;
+use RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source\SomeInterface;
+
+/** @var Container $app */
+$app->bind(function (): \RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source\SomeInterface {
+    return new SomeClass();
+});
+
+$app->bind(function (): \RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source\SomeInterface {
+    return new SomeClass();
+});
+
+$app->singleton(function (): \RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source\SomeInterface {
+    return new SomeClass();
+});
+
+?>

tests/Rector/MethodCall/ContainerBindConcreteWithClosureOnlyRector/Source/SomeClass.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source;
+
+class SomeClass implements SomeInterface {}

tests/Rector/MethodCall/ContainerBindConcreteWithClosureOnlyRector/Source/SomeInterface.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace RectorLaravel\Tests\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector\Source;
+
+interface SomeInterface {}

tests/Rector/MethodCall/ContainerBindConcreteWithClosureOnlyRector/config/configured_rule.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use RectorLaravel\Rector\MethodCall\ContainerBindConcreteWithClosureOnlyRector;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->import(__DIR__ . '/../../../../../config/config.php');
+
+    $rectorConfig->rule(ContainerBindConcreteWithClosureOnlyRector::class);
+};