[PHPUnit60] Fix false positive in AddDoesNotPerformAssertionToNonAssertingTestRector (#687)

The nesting-depth counter in AssertCallAnalyzer was incremented on every
containsAssertCall() but never decremented, so it accumulated across the whole
depth-first walk of a single test method instead of tracking real recursion
depth.

When a non-asserting call (e.g. a production static call) was visited before an
assert-performing helper, it exhausted the level-5 budget; the later helper was
then short-circuited to "no assertions" and the test wrongly got
@doesNotPerformAssertions.

Wrap the body in try/finally so the level is restored on unwind. Add a keep
fixture with a deep non-asserting chain preceding an assert helper.

Author: TomasVotruba

rules-tests/PHPUnit60/Rector/ClassMethod/AddDoesNotPerformAssertionToNonAssertingTestRector/Fixture/keep_deep_calls_before_assert_helper.php.inc

@@ -0,0 +1,47 @@
+<?php
+
+namespace Rector\PHPUnit\Tests\PHPUnit60\Rector\ClassMethod\AddDoesNotPerformAssertionToNonAssertingTestRector\Fixture;
+
+use PHPUnit\Framework\TestCase;
+
+class KeepDeepCallsBeforeAssertHelper extends TestCase
+{
+    public function testSomething(): void
+    {
+        // a deep, non-asserting call chain visited before the assert helper;
+        // it must not exhaust the nested-call budget and hide the assertion below
+        $this->prepare();
+
+        $this->checkResult(true);
+    }
+
+    private function prepare(): void
+    {
+        $this->stepTwo();
+    }
+
+    private function stepTwo(): void
+    {
+        $this->stepThree();
+    }
+
+    private function stepThree(): void
+    {
+        $this->stepFour();
+    }
+
+    private function stepFour(): void
+    {
+        $this->stepFive();
+    }
+
+    private function stepFive(): void
+    {
+        // no assertion here
+    }
+
+    private function checkResult(bool $bool): void
+    {
+        self::assertTrue($bool);
+    }
+}

src/NodeAnalyzer/AssertCallAnalyzer.php

@@ -61,29 +61,34 @@ public function containsAssertCall(ClassMethod $classMethod): bool
     {
         ++$this->classMethodNestingLevel;
 
-        // probably no assert method in the end
-        if ($this->classMethodNestingLevel > self::MAX_NESTED_METHOD_CALL_LEVEL) {
-            return false;
-        }
+        try {
+            // probably no assert method in the end
+            if ($this->classMethodNestingLevel > self::MAX_NESTED_METHOD_CALL_LEVEL) {
+                return false;
+            }
 
-        $cacheHash = md5($this->betterStandardPrinter->prettyPrint([$classMethod]));
+            $cacheHash = md5($this->betterStandardPrinter->prettyPrint([$classMethod]));
 
-        if (isset($this->containsAssertCallByClassMethod[$cacheHash])) {
-            return $this->containsAssertCallByClassMethod[$cacheHash];
-        }
+            if (isset($this->containsAssertCallByClassMethod[$cacheHash])) {
+                return $this->containsAssertCallByClassMethod[$cacheHash];
+            }
 
-        // A. try "->assert" shallow search first for performance
-        $hasDirectAssertOrMockCall = $this->hasDirectAssertOrMockCall($classMethod);
-        if ($hasDirectAssertOrMockCall) {
-            $this->containsAssertCallByClassMethod[$cacheHash] = $hasDirectAssertOrMockCall;
-            return true;
-        }
+            // A. try "->assert" shallow search first for performance
+            $hasDirectAssertOrMockCall = $this->hasDirectAssertOrMockCall($classMethod);
+            if ($hasDirectAssertOrMockCall) {
+                $this->containsAssertCallByClassMethod[$cacheHash] = $hasDirectAssertOrMockCall;
+                return true;
+            }
 
-        // B. look for nested calls
-        $hasNestedAssertOrMockCall = $this->hasNestedAssertCall($classMethod);
-        $this->containsAssertCallByClassMethod[$cacheHash] = $hasNestedAssertOrMockCall;
+            // B. look for nested calls
+            $hasNestedAssertOrMockCall = $this->hasNestedAssertCall($classMethod);
+            $this->containsAssertCallByClassMethod[$cacheHash] = $hasNestedAssertOrMockCall;
 
-        return $hasNestedAssertOrMockCall;
+            return $hasNestedAssertOrMockCall;
+        } finally {
+            // restore depth so sibling calls in the same DFS keep their full budget
+            --$this->classMethodNestingLevel;
+        }
     }
 
     public function isAssertMethodCall(MethodCall|StaticCall $call): bool