[StrictTypes] Add MethodCall/StaticCall to ExclusiveNativeCallLikeRet…

…urnMatcher (#2646)
rectorphp · Jul 9, 2022 · fba410b · fba410b
1 parent f9916a1
commit fba410b
Show file tree

Hide file tree

Showing 13 changed files with 138 additions and 81 deletions.
diff --git a/build/target-repository/docs/rector_rules_overview.md b/build/target-repository/docs/rector_rules_overview.md
@@ -9620,11 +9620,11 @@ Add strict return type based on returned strict expr type
 
 <br>
 
-### ReturnTypeFromStrictNativeFuncCallRector
+### ReturnTypeFromStrictNativeCallRector
 
-Add strict return type based native function return
+Add strict return type based native function or class method return
 
-- class: [`Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeFuncCallRector`](../rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromStrictNativeFuncCallRector.php)
+- class: [`Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector`](../rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromStrictNativeCallRector.php)
 
 ```diff
  final class SomeClass

diff --git a/config/set/type-declaration-strict.php b/config/set/type-declaration-strict.php
@@ -10,7 +10,7 @@
 use Rector\TypeDeclaration\Rector\ClassMethod\ParamTypeByParentCallTypeRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromReturnNewRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictBoolReturnExprRector;
-use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeFuncCallRector;
+use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNewArrayRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictTypedCallRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictTypedPropertyRector;
@@ -33,7 +33,7 @@
         AddMethodCallBasedStrictParamTypeRector::class,
         ArrayShapeFromConstantArrayReturnRector::class,
         ReturnTypeFromStrictBoolReturnExprRector::class,
-        ReturnTypeFromStrictNativeFuncCallRector::class,
+        ReturnTypeFromStrictNativeCallRector::class,
         ReturnTypeFromStrictNewArrayRector::class,
         ReturnTypeFromStrictScalarReturnExprRector::class,
         TypedPropertyFromStrictSetUpRector::class,

diff --git a/phpstan.neon b/phpstan.neon
@@ -385,6 +385,7 @@ parameters:
                 - src/*/*Processor.php
                 - rules/Composer/Application/FileProcessor/ComposerFileProcessor.php
                 - src/Contract/Processor/FileProcessorInterface.php
+                - packages/Parallel/Application/ParallelFileProcessor.php
 
         # skipped on purpose, as ctor overrie
         - '#Rector\\StaticTypeMapper\\ValueObject\\Type\\SimpleStaticType\:\:__construct\(\) does not call parent constructor from PHPStan\\Type\\StaticType#'

diff --git a/...tor/ClassMethod/ReturnTypeFromStrictNativeCallRector/Fixture/skip_custom_function.php.inc b/...tor/ClassMethod/ReturnTypeFromStrictNativeCallRector/Fixture/skip_custom_function.php.inc
@@ -0,0 +1,16 @@
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector\Fixture;
+
+function custom_function(): string
+{
+    return 'yes';
+}
+
+final class SkipCustomFunction
+{
+    public function run()
+    {
+        return custom_function();
+    }
+}
diff --git a/...FuncCallRector/Fixture/some_class.php.inc → ...tiveCallRector/Fixture/some_class.php.inc b/...FuncCallRector/Fixture/some_class.php.inc → ...tiveCallRector/Fixture/some_class.php.inc
@@ -1,6 +1,6 @@
 <?php
 
-namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeFuncCallRector\Fixture;
+namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector\Fixture;
 
 final class SomeClass
 {
@@ -14,7 +14,7 @@ final class SomeClass
 -----
 <?php
 
-namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeFuncCallRector\Fixture;
+namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector\Fixture;
 
 final class SomeClass
 {

diff --git a/.../ClassMethod/ReturnTypeFromStrictNativeCallRector/Fixture/some_native_method_call.php.inc b/.../ClassMethod/ReturnTypeFromStrictNativeCallRector/Fixture/some_native_method_call.php.inc
@@ -0,0 +1,27 @@
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector\Fixture;
+
+final class SomeNativeMethodCall
+{
+    public function run(\SplFileInfo $splFileInfo)
+    {
+        return $splFileInfo->isDir();
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector\Fixture;
+
+final class SomeNativeMethodCall
+{
+    public function run(\SplFileInfo $splFileInfo): bool
+    {
+        return $splFileInfo->isDir();
+    }
+}
+
+?>
diff --git a/...ypeFromStrictNativeFuncCallRectorTest.php → ...urnTypeFromStrictNativeCallRectorTest.php b/...ypeFromStrictNativeFuncCallRectorTest.php → ...urnTypeFromStrictNativeCallRectorTest.php
@@ -2,13 +2,13 @@
 
 declare(strict_types=1);
 
-namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeFuncCallRector;
+namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector;
 
 use Iterator;
 use Rector\Testing\PHPUnit\AbstractRectorTestCase;
 use Symplify\SmartFileSystem\SmartFileInfo;
 
-final class ReturnTypeFromStrictNativeFuncCallRectorTest extends AbstractRectorTestCase
+final class ReturnTypeFromStrictNativeCallRectorTest extends AbstractRectorTestCase
 {
     /**
      * @dataProvider provideData()

diff --git a/...FuncCallRector/config/configured_rule.php → ...tiveCallRector/config/configured_rule.php b/...FuncCallRector/config/configured_rule.php → ...tiveCallRector/config/configured_rule.php
@@ -4,8 +4,8 @@
 
 use Rector\Config\RectorConfig;
 
-use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeFuncCallRector;
+use Rector\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector;
 
 return static function (RectorConfig $rectorConfig): void {
-    $rectorConfig->rule(ReturnTypeFromStrictNativeFuncCallRector::class);
+    $rectorConfig->rule(ReturnTypeFromStrictNativeCallRector::class);
 };
diff --git a/rules/TypeDeclaration/NodeAnalyzer/ReturnFilter/ExclusiveNativeCallLikeReturnMatcher.php b/rules/TypeDeclaration/NodeAnalyzer/ReturnFilter/ExclusiveNativeCallLikeReturnMatcher.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\TypeDeclaration\NodeAnalyzer\ReturnFilter;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\FuncCall;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\StaticCall;
+use PhpParser\Node\Stmt\Return_;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\MethodReflection;
+use Rector\Core\Reflection\ReflectionResolver;
+
+final class ExclusiveNativeCallLikeReturnMatcher
+{
+    public function __construct(
+        private readonly ReflectionResolver $reflectionResolver,
+    ) {
+    }
+
+    /**
+     * @param Return_[] $returns
+     * @return array<StaticCall|FuncCall|MethodCall>|null
+     */
+    public function match(array $returns): array|null
+    {
+        $callLikes = [];
+
+        foreach ($returns as $return) {
+            // we need exact expr return
+            $returnExpr = $return->expr;
+            if (! $returnExpr instanceof StaticCall && ! $returnExpr instanceof MethodCall && ! $returnExpr instanceof FuncCall) {
+                return null;
+            }
+
+            $functionLikeReflection = $this->reflectionResolver->resolveFunctionLikeReflectionFromCall($returnExpr);
+
+            if (! $functionLikeReflection instanceof FunctionReflection && ! $functionLikeReflection instanceof MethodReflection) {
+                return null;
+            }
+
+            // is native func call?
+            if (! $this->isNativeCallLike($functionLikeReflection)) {
+                return null;
+            }
+
+            $callLikes[] = $returnExpr;
+        }
+
+        return $callLikes;
+    }
+
+    private function isNativeCallLike(MethodReflection|FunctionReflection $functionLikeReflection): bool
+    {
+        if ($functionLikeReflection instanceof FunctionReflection) {
+            return $functionLikeReflection->isBuiltin();
+        }
+
+        // is native method call?
+        $classReflection = $functionLikeReflection->getDeclaringClass();
+        return $classReflection->isBuiltin();
+    }
+}
diff --git a/rules/TypeDeclaration/NodeAnalyzer/ReturnFilter/ExclusiveNativeFuncCallReturnMatcher.php b/rules/TypeDeclaration/NodeAnalyzer/ReturnFilter/ExclusiveNativeFuncCallReturnMatcher.php
diff --git a/...ypeDeclaration/NodeAnalyzer/ReturnTypeAnalyzer/StrictNativeFunctionReturnTypeAnalyzer.php b/...ypeDeclaration/NodeAnalyzer/ReturnTypeAnalyzer/StrictNativeFunctionReturnTypeAnalyzer.php
@@ -5,27 +5,27 @@
 namespace Rector\TypeDeclaration\NodeAnalyzer\ReturnTypeAnalyzer;
 
 use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\CallLike;
 use PhpParser\Node\Expr\Closure;
-use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\Yield_;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Function_;
 use PhpParser\Node\Stmt\Return_;
 use Rector\Core\PhpParser\Node\BetterNodeFinder;
-use Rector\TypeDeclaration\NodeAnalyzer\ReturnFilter\ExclusiveNativeFuncCallReturnMatcher;
+use Rector\TypeDeclaration\NodeAnalyzer\ReturnFilter\ExclusiveNativeCallLikeReturnMatcher;
 
 final class StrictNativeFunctionReturnTypeAnalyzer
 {
     public function __construct(
         private readonly BetterNodeFinder $betterNodeFinder,
-        private readonly ExclusiveNativeFuncCallReturnMatcher $exclusiveNativeFuncCallReturnMatcher
+        private readonly ExclusiveNativeCallLikeReturnMatcher $exclusiveNativeCallLikeReturnMatcher
     ) {
     }
 
     /**
-     * @return FuncCall[]|null
+     * @return CallLike[]|null
      */
-    public function matchAlwaysReturnNativeFuncCalls(ClassMethod|Closure|Function_ $functionLike): ?array
+    public function matchAlwaysReturnNativeCallLikes(ClassMethod|Closure|Function_ $functionLike): ?array
     {
         if ($functionLike->stmts === null) {
             return null;
@@ -51,12 +51,12 @@ public function matchAlwaysReturnNativeFuncCalls(ClassMethod|Closure|Function_ $
             return null;
         }
 
-        $nativeFuncCalls = $this->exclusiveNativeFuncCallReturnMatcher->match($returns);
-        if ($nativeFuncCalls === null) {
+        $nativeCalls = $this->exclusiveNativeCallLikeReturnMatcher->match($returns);
+        if ($nativeCalls === null) {
             return null;
         }
 
-        return $nativeFuncCalls;
+        return $nativeCalls;
     }
 
     /**

diff --git a/...urnTypeFromStrictNativeFuncCallRector.php → .../ReturnTypeFromStrictNativeCallRector.php b/...urnTypeFromStrictNativeFuncCallRector.php → .../ReturnTypeFromStrictNativeCallRector.php
@@ -19,9 +19,9 @@
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
 /**
- * @see \Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeFuncCallRector\ReturnTypeFromStrictNativeFuncCallRectorTest
+ * @see \Rector\Tests\TypeDeclaration\Rector\ClassMethod\ReturnTypeFromStrictNativeCallRector\ReturnTypeFromStrictNativeCallRectorTest
  */
-final class ReturnTypeFromStrictNativeFuncCallRector extends AbstractRector implements MinPhpVersionInterface
+final class ReturnTypeFromStrictNativeCallRector extends AbstractRector implements MinPhpVersionInterface
 {
     public function __construct(
         private readonly StrictNativeFunctionReturnTypeAnalyzer $strictNativeFunctionReturnTypeAnalyzer,
@@ -31,7 +31,7 @@ public function __construct(
 
     public function getRuleDefinition(): RuleDefinition
     {
-        return new RuleDefinition('Add strict return type based native function return', [
+        return new RuleDefinition('Add strict return type based native function or class method return', [
             new CodeSample(
                 <<<'CODE_SAMPLE'
 final class SomeClass
@@ -74,17 +74,17 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        $nativeFuncCalls = $this->strictNativeFunctionReturnTypeAnalyzer->matchAlwaysReturnNativeFuncCalls($node);
-        if ($nativeFuncCalls === null) {
+        $nativeCallLikes = $this->strictNativeFunctionReturnTypeAnalyzer->matchAlwaysReturnNativeCallLikes($node);
+        if ($nativeCallLikes === null) {
             return null;
         }
 
-        $funcCallTypes = [];
-        foreach ($nativeFuncCalls as $nativeFuncCall) {
-            $funcCallTypes[] = $this->getType($nativeFuncCall);
+        $callLikeTypes = [];
+        foreach ($nativeCallLikes as $nativeCallLike) {
+            $callLikeTypes[] = $this->getType($nativeCallLike);
         }
 
-        $returnType = $this->typeFactory->createMixedPassedOrUnionType($funcCallTypes);
+        $returnType = $this->typeFactory->createMixedPassedOrUnionType($callLikeTypes);
         if ($returnType instanceof MixedType) {
             return null;
         }

diff --git a/src/Reflection/ReflectionResolver.php b/src/Reflection/ReflectionResolver.php
@@ -165,7 +165,7 @@ public function resolveMethodReflectionFromMethodCall(MethodCall $methodCall): ?
     }
 
     public function resolveFunctionLikeReflectionFromCall(
-        MethodCall | StaticCall | FuncCall $call
+        MethodCall|FuncCall|StaticCall $call
     ): MethodReflection | FunctionReflection | null {
         if ($call instanceof MethodCall) {
             return $this->resolveMethodReflectionFromMethodCall($call);