fix(phpstan): fix CI failures in RequireVariadicForSingleListParamRule

- Remove redundant assert($node instanceof ClassMethod) — PHPStan already
  knows the type via @implements Rule<ClassMethod>, making the assert
  always-true
- Replace createStub(Scope::class) with createMockForIntersectionOfInterfaces
  ([NodeCallbackInvoker::class, Scope::class]) — Scope parameter requires
  NodeCallbackInvoker intersection to satisfy PHPStan's type for processNode()
- Remove redundant (string) casts on getMessage() which already returns string
- Add PHPStan\Analyser\NodeCallbackInvoker to composerRequireChecker whitelist

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: LTSCommerce

qaConfig/composerRequireChecker.json

@@ -59,6 +59,7 @@
     "PhpParser\\Node\\Expr\\Ternary",
     "PhpParser\\Node\\NullableType",
     "PhpParser\\Node\\Param",
+    "PHPStan\\Analyser\\NodeCallbackInvoker",
     "PHPStan\\Analyser\\Scope",
     "PHPStan\\Node\\FileNode",
     "PHPStan\\Reflection\\ClassReflection",

src/PHPStan/Rules/RequireVariadicForSingleListParamRule.php

@@ -47,8 +47,6 @@ public function getNodeType(): string
      */
     public function processNode(Node $node, Scope $scope): array
     {
-        \assert($node instanceof ClassMethod);
-
         if (1 !== \count($node->params)) {
             return [];
         }

tests/Small/PHPStan/Rules/RequireVariadicForSingleListParamRuleTest.php

@@ -10,6 +10,8 @@
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Param;
 use PhpParser\Node\Stmt\ClassMethod;
+use PHPStan\Analyser\NodeCallbackInvoker;
+use PHPStan\Analyser\Scope;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -39,7 +41,7 @@ public function testSingleArrayParamWithListDocblockIsFlagged(): void
             '/** @param list<ProductEnquiryItem> $items */',
         );
 
-        self::assertCount(1, $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertCount(1, $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testErrorMessageContainsMethodAndParamName(): void
@@ -50,11 +52,11 @@ public function testErrorMessageContainsMethodAndParamName(): void
             '/** @param list<string> $records */',
         );
 
-        $errors = $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class));
+        $errors = $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class]));
 
         self::assertCount(1, $errors);
-        self::assertStringContainsString('process()', (string) $errors[0]->getMessage());
-        self::assertStringContainsString('$records', (string) $errors[0]->getMessage());
+        self::assertStringContainsString('process()', $errors[0]->getMessage());
+        self::assertStringContainsString('$records', $errors[0]->getMessage());
     }
 
     public function testMultipleParamsAreNotFlagged(): void
@@ -65,21 +67,21 @@ public function testMultipleParamsAreNotFlagged(): void
             '/** @param list<string> $items */',
         );
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testZeroParamsAreNotFlagged(): void
     {
         $method = $this->makeMethod('render', [], '/** no params */');
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testNoDocblockIsNotFlagged(): void
     {
         $method = $this->makeMethod('render', [$this->makeArrayParam('items')], null);
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testArrayDocblockIsNotFlagged(): void
@@ -90,7 +92,7 @@ public function testArrayDocblockIsNotFlagged(): void
             '/** @param array<string> $items */',
         );
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testIterableDocblockIsNotFlagged(): void
@@ -101,7 +103,7 @@ public function testIterableDocblockIsNotFlagged(): void
             '/** @param iterable<string> $items */',
         );
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testAlreadyVariadicIsNotFlagged(): void
@@ -113,15 +115,15 @@ public function testAlreadyVariadicIsNotFlagged(): void
             '/** @param list<string> $items */',
         );
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testNonArrayTypeIsNotFlagged(): void
     {
         $param  = new Param(new Variable('items'), null, new Identifier('string'));
         $method = $this->makeMethod('render', [$param], '/** @param list<string> $items */');
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testNullableArrayTypeIsNotFlagged(): void
@@ -130,15 +132,15 @@ public function testNullableArrayTypeIsNotFlagged(): void
         $param        = new Param(new Variable('items'), null, $nullableType);
         $method       = $this->makeMethod('render', [$param], '/** @param list<string> $items */');
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testUntypedParamIsNotFlagged(): void
     {
         $param  = new Param(new Variable('items'));
         $method = $this->makeMethod('render', [$param], '/** @param list<string> $items */');
 
-        self::assertSame([], $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertSame([], $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     public function testNestedGenericListIsFlagged(): void
@@ -149,7 +151,7 @@ public function testNestedGenericListIsFlagged(): void
             '/** @param list<Type<A, B>> $items */',
         );
 
-        self::assertCount(1, $this->rule->processNode($method, $this->createStub(\PHPStan\Analyser\Scope::class)));
+        self::assertCount(1, $this->rule->processNode($method, $this->createMockForIntersectionOfInterfaces([NodeCallbackInvoker::class, Scope::class])));
     }
 
     /**