add implicit method call support (#581)

* add implicit method call support

* cs

* cs

Author: TomasVotruba

rules-tests/CodeQuality/Rector/MethodCall/WithCallbackIdenticalToStandaloneAssertsRector/Fixture/assert_method_call_true.php.inc

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\WithCallbackIdenticalToStandaloneAssertsRector\Fixture;
+
+use PHPUnit\Framework\TestCase;
+use Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\WithCallbackIdenticalToStandaloneAssertsRector\Source\SomeClassWithMethodCall;
+
+final class AssertMethodCallTrue extends TestCase
+{
+    public function test()
+    {
+        $someMock = $this->getMockBuilder('AnyType')->getMock();
+
+        $someMock->expects($this->any())
+            ->method('trans')
+            ->with($this->callback(fn ($arg) => $arg instanceof SomeClassWithMethodCall && $arg->isReady()));
+    }
+}
+
+?>
+-----
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\WithCallbackIdenticalToStandaloneAssertsRector\Fixture;
+
+use PHPUnit\Framework\TestCase;
+use Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\WithCallbackIdenticalToStandaloneAssertsRector\Source\SomeClassWithMethodCall;
+
+final class AssertMethodCallTrue extends TestCase
+{
+    public function test()
+    {
+        $someMock = $this->getMockBuilder('AnyType')->getMock();
+
+        $someMock->expects($this->any())
+            ->method('trans')
+            ->with($this->callback(function ($arg): bool {
+                $this->assertInstanceOf(\Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\WithCallbackIdenticalToStandaloneAssertsRector\Source\SomeClassWithMethodCall::class, $arg);
+                $this->assertTrue($arg->isReady());
+                return true;
+            }));
+    }
+}
+
+?>

rules-tests/CodeQuality/Rector/MethodCall/WithCallbackIdenticalToStandaloneAssertsRector/Source/SomeClassWithMethodCall.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\WithCallbackIdenticalToStandaloneAssertsRector\Source;
+
+final class SomeClassWithMethodCall
+{
+    public function isReady(): bool
+    {
+        return mt_rand(0, 1) === 1;
+    }
+}

rules/CodeQuality/NodeAnalyser/ClosureUsesResolver.php

@@ -51,12 +51,7 @@ public function resolveFromArrowFunction(ArrowFunction $arrowFunction): array
         $externalVariableNames = array_unique($externalVariableNames);
         $externalVariableNames = array_diff($externalVariableNames, ['this']);
 
-        $closureUses = [];
-        foreach ($externalVariableNames as $externalVariableName) {
-            $closureUses[] = new ClosureUse(new Variable($externalVariableName));
-        }
-
-        return $closureUses;
+        return $this->createClosureUses($externalVariableNames);
     }
 
     /**
@@ -71,4 +66,18 @@ private function resolveParamNames(ArrowFunction $arrowFunction): array
 
         return $paramNames;
     }
+
+    /**
+     * @param string[] $externalVariableNames
+     * @return ClosureUse[]
+     */
+    private function createClosureUses(array $externalVariableNames): array
+    {
+        $closureUses = [];
+        foreach ($externalVariableNames as $externalVariableName) {
+            $closureUses[] = new ClosureUse(new Variable($externalVariableName));
+        }
+
+        return $closureUses;
+    }
 }

rules/CodeQuality/NodeFactory/FromBinaryAndAssertExpressionsFactory.php

@@ -12,6 +12,7 @@
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\Instanceof_;
 use PhpParser\Node\Expr\Isset_;
+use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Name;
 use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Scalar\Int_;
@@ -37,6 +38,13 @@ public function create(array $exprs): array
         $assertMethodCalls = [];
 
         foreach ($exprs as $expr) {
+            // implicit bool compare
+            if ($expr instanceof MethodCall) {
+                $assertMethodCalls[] = $this->nodeFactory->createMethodCall('this', 'assertTrue', [$expr]);
+
+                continue;
+            }
+
             if ($expr instanceof FuncCall && $this->nodeNameResolver->isName($expr, 'array_key_exists')) {
                 $variableExpr = $expr->getArgs()[1]
                     ->value;

rules/CodeQuality/Rector/MethodCall/WithCallbackIdenticalToStandaloneAssertsRector.php

@@ -125,34 +125,24 @@ public function refactor(Node $node): MethodCall|null
                 continue;
             }
 
-            $assertExpressions = $this->fromBinaryAndAssertExpressionsFactory->create($joinedExprs);
-            if ($assertExpressions === []) {
+            $assertExprStmts = $this->fromBinaryAndAssertExpressionsFactory->create($joinedExprs);
+            if ($assertExprStmts === []) {
                 continue;
             }
 
             $nonReturnCallbackStmts = $this->resolveNonReturnCallbackStmts($argAndFunctionLike);
 
             // last si return true;
-            $assertExpressions[] = new Return_($this->nodeFactory->createTrue());
-
+            $assertExprStmts[] = new Return_($this->nodeFactory->createTrue());
             $innerFunctionLike = $argAndFunctionLike->getFunctionLike();
 
             if ($innerFunctionLike instanceof Closure) {
-                $innerFunctionLike->stmts = array_merge($nonReturnCallbackStmts, $assertExpressions);
+                $innerFunctionLike->stmts = array_merge($nonReturnCallbackStmts, $assertExprStmts);
             } else {
                 // arrow function -> flip to closure
                 $functionLikeInArg = $argAndFunctionLike->getArg();
 
-                $externalVariables = $this->closureUsesResolver->resolveFromArrowFunction($innerFunctionLike);
-
-                $closure = new Closure([
-                    'params' => $argAndFunctionLike->getFunctionLike()
-                        ->params,
-                    'stmts' => $assertExpressions,
-                    'returnType' => new Identifier('bool'),
-                    'uses' => $externalVariables,
-                ]);
-
+                $closure = $this->createClosure($innerFunctionLike, $argAndFunctionLike, $assertExprStmts);
                 $functionLikeInArg->value = $closure;
             }
 
@@ -273,4 +263,23 @@ private function resolveNonReturnCallbackStmts(ArgAndFunctionLike $argAndFunctio
 
         return [];
     }
+
+    /**
+     * @param Stmt[] $assertExprStmts
+     */
+    private function createClosure(
+        ArrowFunction $arrowFunction,
+        ArgAndFunctionLike $argAndFunctionLike,
+        array $assertExprStmts
+    ): Closure {
+        $externalVariables = $this->closureUsesResolver->resolveFromArrowFunction($arrowFunction);
+
+        return new Closure([
+            'params' => $argAndFunctionLike->getFunctionLike()
+                ->params,
+            'stmts' => $assertExprStmts,
+            'returnType' => new Identifier('bool'),
+            'uses' => $externalVariables,
+        ]);
+    }
 }