use ClassMethodReturnTypeOverrideGuard

Author: TomasVotruba

rules-tests/TypeDeclaration/Rector/ClassMethod/AddReturnTypeFromTryCatchTypeRector/Fixture/skip_if_no_catch.php.inc

@@ -0,0 +1,15 @@
+<?php
+
+namespace Rector\Tests\TypeDeclaration\Rector\ClassMethod\AddReturnTypeFromTryCatchTypeRector\Fixture;
+
+final class SkipIfNoCatch
+{
+    public function run()
+    {
+        try {
+            return 1;
+        } finally {
+            return 5;
+        }
+    }
+}

rules/TypeDeclaration/Rector/ClassMethod/AddReturnTypeFromTryCatchTypeRector.php

@@ -4,14 +4,19 @@
 
 namespace Rector\TypeDeclaration\Rector\ClassMethod;
 
+use PhpParser\Node\Stmt\TryCatch;
+use PHPStan\Type\Type;
+use PhpParser\Node\Stmt\Catch_;
+use PhpParser\Node\Stmt\Return_;
+use PhpParser\Node\Expr;
 use PhpParser\Node;
 use PhpParser\Node\Stmt\ClassMethod;
-use PHPStan\Reflection\ClassReflection;
 use Rector\NodeTypeResolver\TypeComparator\TypeComparator;
 use Rector\PHPStan\ScopeFetcher;
 use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
 use Rector\Rector\AbstractRector;
 use Rector\StaticTypeMapper\StaticTypeMapper;
+use Rector\VendorLocker\NodeVendorLocker\ClassMethodReturnTypeOverrideGuard;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -21,8 +26,9 @@
 final class AddReturnTypeFromTryCatchTypeRector extends AbstractRector
 {
     public function __construct(
-        private TypeComparator $typeComparator,
-        private StaticTypeMapper $staticTypeMapper,
+        private readonly TypeComparator $typeComparator,
+        private readonly StaticTypeMapper $staticTypeMapper,
+        private readonly ClassMethodReturnTypeOverrideGuard $classMethodReturnTypeOverrideGuard,
     ) {
 
     }
@@ -78,32 +84,26 @@ public function getNodeTypes(): array
      */
     public function refactor(Node $node): ?Node
     {
-        // better nothing to do
-        if ($node->isAbstract()) {
-            return null;
-        }
-
-        // already known type
-        if ($node->returnType instanceof \PhpParser\Node) {
-            return null;
-        }
-
         $scope = ScopeFetcher::fetch($node);
-        $classReflection = $scope->getClassReflection();
-        if (! $classReflection instanceof ClassReflection) {
+        if ($this->classMethodReturnTypeOverrideGuard->shouldSkipClassMethod($node, $scope)) {
             return null;
         }
 
-        // skip interfaces and traits
-        if (! $classReflection->isClass()) {
+        // already known type
+        if ($node->returnType instanceof Node) {
             return null;
         }
 
         $tryReturnType = null;
         $catchReturnTypes = [];
 
         foreach ((array) $node->stmts as $classMethodStmt) {
-            if (! $classMethodStmt instanceof Node\Stmt\TryCatch) {
+            if (! $classMethodStmt instanceof TryCatch) {
+                continue;
+            }
+
+            // skip if there is no catch
+            if ($classMethodStmt->catches === []) {
                 continue;
             }
 
@@ -114,15 +114,15 @@ public function refactor(Node $node): ?Node
                 $currentCatchType = $this->matchReturnType($catch);
 
                 // each catch must have type
-                if (! $currentCatchType instanceof \PHPStan\Type\Type) {
+                if (! $currentCatchType instanceof Type) {
                     return null;
                 }
 
                 $catchReturnTypes[] = $currentCatchType;
             }
         }
 
-        if (! $tryReturnType instanceof \PHPStan\Type\Type) {
+        if (! $tryReturnType instanceof Type) {
             return null;
         }
 
@@ -133,22 +133,22 @@ public function refactor(Node $node): ?Node
         }
 
         $returnType = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($tryReturnType, TypeKind::RETURN);
-        if (! $returnType instanceof \PhpParser\Node) {
+        if (! $returnType instanceof Node) {
             return null;
         }
 
         $node->returnType = $returnType;
         return $node;
     }
 
-    private function matchReturnType(Node\Stmt\TryCatch|Node\Stmt\Catch_ $tryOrCatch): ?\PHPStan\Type\Type
+    private function matchReturnType(TryCatch|Catch_ $tryOrCatch): ?Type
     {
         foreach ($tryOrCatch->stmts as $stmt) {
-            if (! $stmt instanceof Node\Stmt\Return_) {
+            if (! $stmt instanceof Return_) {
                 continue;
             }
 
-            if (! $stmt->expr instanceof Node\Expr) {
+            if (! $stmt->expr instanceof Expr) {
                 continue;
             }