style: apply php-cs-fixer and PHPStan fixes (#289)

* style: apply php-cs-fixer to test files

Addresses drift flagged by the default PHP-CS-Fixer config — mostly
adds missing `: void` return types on pre-existing test methods.

No behavioural changes.

* fix: resolve phpstan errors surfaced by qa

- Drop the obsolete `Method ::test*() has no return type specified`
  ignore rule — every test method now declares a return type, so
  the pattern never matches and phpstan reports it as unmatched.
- Remove `?? []` from two reads of `CallToolRequest::$arguments`;
  the property is typed `array` (non-nullable), so the coalesce is
  a no-op that phpstan flags.

---------

Co-authored-by: DDEV User <nobody@example.com>

Author: e0ipso

examples/server/custom-method-handlers/CallToolRequestHandler.php

@@ -44,7 +44,7 @@ public function handle(Request $request, SessionInterface $session): Response|Er
         \assert($request instanceof CallToolRequest);
 
         $name = $request->name;
-        $args = $request->arguments ?? [];
+        $args = $request->arguments;
 
         if (!isset($this->toolDefinitions[$name])) {
             return new Error($request->getId(), Error::METHOD_NOT_FOUND, \sprintf('Tool not found: %s', $name));

phpstan.dist.neon

@@ -13,8 +13,6 @@ parameters:
         - tests/Unit/Capability/Discovery/SchemaGeneratorFixture.php
     treatPhpDocTypesAsCertain: false
     ignoreErrors:
-        -
-            message: "#^Method .*::test.*\\(\\) has no return type specified\\.$#"
         -
             identifier: missingType.iterableValue
             path: tests/

src/Server/Handler/Request/CallToolHandler.php

@@ -58,7 +58,7 @@ public function handle(Request $request, SessionInterface $session): Response|Er
         \assert($request instanceof CallToolRequest);
 
         $toolName = $request->name;
-        $arguments = $request->arguments ?? [];
+        $arguments = $request->arguments;
 
         $this->logger->debug('Executing tool', ['name' => $toolName, 'arguments' => $arguments]);
 

tests/Unit/Capability/Discovery/DiscoveryTest.php

@@ -32,7 +32,7 @@ protected function setUp(): void
         $this->discoverer = new Discoverer();
     }
 
-    public function testDiscoversAllElementTypesCorrectlyFromFixtureFiles()
+    public function testDiscoversAllElementTypesCorrectlyFromFixtureFiles(): void
     {
         $discovery = $this->discoverer->discover(__DIR__, ['Fixtures']);
 
@@ -105,7 +105,7 @@ public function testDiscoversAllElementTypesCorrectlyFromFixtureFiles()
         $this->assertEquals([InvocableResourceTemplateFixture::class, '__invoke'], $templates['invokable://user-profile/{userId}']->handler);
     }
 
-    public function testDoesNotDiscoverElementsFromExcludedDirectories()
+    public function testDoesNotDiscoverElementsFromExcludedDirectories(): void
     {
         $discovery = $this->discoverer->discover(__DIR__, ['Fixtures']);
         $this->assertArrayHasKey('hidden_subdir_tool', $discovery->getTools());
@@ -114,14 +114,14 @@ public function testDoesNotDiscoverElementsFromExcludedDirectories()
         $this->assertArrayNotHasKey('hidden_subdir_tool', $discovery->getTools());
     }
 
-    public function testHandlesEmptyDirectoriesOrDirectoriesWithNoPhpFiles()
+    public function testHandlesEmptyDirectoriesOrDirectoriesWithNoPhpFiles(): void
     {
         $discovery = $this->discoverer->discover(__DIR__, ['EmptyDir']);
 
         $this->assertTrue($discovery->isEmpty());
     }
 
-    public function testCorrectlyInfersNamesAndDescriptionsFromMethodsOrClassesIfNotSetInAttribute()
+    public function testCorrectlyInfersNamesAndDescriptionsFromMethodsOrClassesIfNotSetInAttribute(): void
     {
         $discovery = $this->discoverer->discover(__DIR__, ['Fixtures']);
 
@@ -138,7 +138,7 @@ public function testCorrectlyInfersNamesAndDescriptionsFromMethodsOrClassesIfNot
         $this->assertEquals('An invokable calculator tool.', $tools['InvokableCalculator']->tool->description);
     }
 
-    public function testDiscoversEnhancedCompletionProvidersWithValuesAndEnumAttributes()
+    public function testDiscoversEnhancedCompletionProvidersWithValuesAndEnumAttributes(): void
     {
         $discovery = $this->discoverer->discover(__DIR__, ['Fixtures']);
 

tests/Unit/Capability/Discovery/DocBlockParserTest.php

@@ -29,7 +29,7 @@ protected function setUp(): void
         $this->parser = new DocBlockParser();
     }
 
-    public function testGetDescriptionReturnsCorrectDescription()
+    public function testGetDescriptionReturnsCorrectDescription(): void
     {
         $method = new \ReflectionMethod(DocBlockTestFixture::class, 'methodWithSummaryAndDescription');
         $docComment = $method->getDocComment() ?: null;
@@ -43,7 +43,7 @@ public function testGetDescriptionReturnsCorrectDescription()
         $this->assertEquals('Simple summary line.', $this->parser->getDescription($docBlock2));
     }
 
-    public function testGetParamTagsReturnsStructuredParamInfo()
+    public function testGetParamTagsReturnsStructuredParamInfo(): void
     {
         $method = new \ReflectionMethod(DocBlockTestFixture::class, 'methodWithParams');
         $docComment = $method->getDocComment() ?: null;
@@ -94,7 +94,7 @@ public function testGetParamTagsReturnsStructuredParamInfo()
         $this->assertEquals('object param', $this->parser->getParamDescription($params['$param6']));
     }
 
-    public function testGetTagsByNameReturnsSpecificTags()
+    public function testGetTagsByNameReturnsSpecificTags(): void
     {
         $method = new \ReflectionMethod(DocBlockTestFixture::class, 'methodWithMultipleTags');
         $docComment = $method->getDocComment() ?: null;
@@ -116,7 +116,7 @@ public function testGetTagsByNameReturnsSpecificTags()
         $this->assertEmpty($nonExistentTags);
     }
 
-    public function testHandlesMethodWithNoDocblockGracefully()
+    public function testHandlesMethodWithNoDocblockGracefully(): void
     {
         $method = new \ReflectionMethod(DocBlockTestFixture::class, 'methodWithNoDocBlock');
         $docComment = $method->getDocComment() ?: null;

tests/Unit/Capability/Discovery/Fixtures/NonDiscoverableClass.php

@@ -25,7 +25,7 @@ interface MyDiscoverableInterface
 
 trait MyDiscoverableTrait
 {
-    public function traitMethod()
+    public function traitMethod(): void
     {
     }
 }

tests/Unit/Capability/Discovery/Fixtures/SubDir/HiddenTool.php

@@ -16,7 +16,7 @@
 class HiddenTool
 {
     #[McpTool(name: 'hidden_subdir_tool')]
-    public function run()
+    public function run(): void
     {
     }
 }

tests/Unit/Capability/Discovery/HandlerResolverTest.php

@@ -17,7 +17,7 @@
 
 class HandlerResolverTest extends TestCase
 {
-    public function testResolvesClosuresToReflectionFunction()
+    public function testResolvesClosuresToReflectionFunction(): void
     {
         $closure = static function (string $input): string {
             return "processed: $input";
@@ -29,7 +29,7 @@ public function testResolvesClosuresToReflectionFunction()
         $this->assertEquals('string', $returnType->getName());
     }
 
-    public function testResolvesValidArrayHandler()
+    public function testResolvesValidArrayHandler(): void
     {
         $handler = [ValidHandlerClass::class, 'publicMethod'];
         $resolved = HandlerResolver::resolve($handler);
@@ -38,7 +38,7 @@ public function testResolvesValidArrayHandler()
         $this->assertEquals(ValidHandlerClass::class, $resolved->getDeclaringClass()->getName());
     }
 
-    public function testResolvesValidInvokableClassStringHandler()
+    public function testResolvesValidInvokableClassStringHandler(): void
     {
         $handler = ValidInvokableClass::class;
         $resolved = HandlerResolver::resolve($handler);
@@ -47,7 +47,7 @@ public function testResolvesValidInvokableClassStringHandler()
         $this->assertEquals(ValidInvokableClass::class, $resolved->getDeclaringClass()->getName());
     }
 
-    public function testResolvesStaticMethodsForManualRegistration()
+    public function testResolvesStaticMethodsForManualRegistration(): void
     {
         $handler = [ValidHandlerClass::class, 'staticMethod'];
         $resolved = HandlerResolver::resolve($handler);
@@ -56,84 +56,84 @@ public function testResolvesStaticMethodsForManualRegistration()
         $this->assertTrue($resolved->isStatic());
     }
 
-    public function testThrowsForInvalidArrayHandlerFormatCount()
+    public function testThrowsForInvalidArrayHandlerFormatCount(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage("Invalid array handler format. Expected [ClassName::class, 'methodName'].");
         HandlerResolver::resolve([ValidHandlerClass::class]); /* @phpstan-ignore argument.type */
     }
 
-    public function testThrowsForInvalidArrayHandlerFormatTypes()
+    public function testThrowsForInvalidArrayHandlerFormatTypes(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage("Invalid array handler format. Expected [ClassName::class, 'methodName'].");
         HandlerResolver::resolve([ValidHandlerClass::class, 123]); /* @phpstan-ignore argument.type */
     }
 
-    public function testThrowsForNonExistentClassInArrayHandler()
+    public function testThrowsForNonExistentClassInArrayHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Handler class "NonExistentClass" not found');
         HandlerResolver::resolve(['NonExistentClass', 'method']);
     }
 
-    public function testThrowsForNonExistentMethodInArrayHandler()
+    public function testThrowsForNonExistentMethodInArrayHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Handler method "nonExistentMethod" not found in class');
         HandlerResolver::resolve([ValidHandlerClass::class, 'nonExistentMethod']);
     }
 
-    public function testThrowsForNonExistentClassInStringHandler()
+    public function testThrowsForNonExistentClassInStringHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invalid handler format. Expected Closure, [ClassName::class, \'methodName\'] or InvokableClassName::class string.');
         HandlerResolver::resolve('NonExistentInvokableClass');
     }
 
-    public function testThrowsForNonInvokableClassStringHandler()
+    public function testThrowsForNonInvokableClassStringHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Invokable handler class "Mcp\Tests\Unit\Capability\Discovery\NonInvokableClass" must have a public "__invoke" method.');
         HandlerResolver::resolve(NonInvokableClass::class);
     }
 
-    public function testThrowsForProtectedMethodHandler()
+    public function testThrowsForProtectedMethodHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('must be public');
         HandlerResolver::resolve([ValidHandlerClass::class, 'protectedMethod']);
     }
 
-    public function testThrowsForPrivateMethodHandler()
+    public function testThrowsForPrivateMethodHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('must be public');
         HandlerResolver::resolve([ValidHandlerClass::class, 'privateMethod']);
     }
 
-    public function testThrowsForConstructorAsHandler()
+    public function testThrowsForConstructorAsHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('cannot be a constructor or destructor');
         HandlerResolver::resolve([ValidHandlerClass::class, '__construct']);
     }
 
-    public function testThrowsForDestructorAsHandler()
+    public function testThrowsForDestructorAsHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('cannot be a constructor or destructor');
         HandlerResolver::resolve([ValidHandlerClass::class, '__destruct']);
     }
 
-    public function testThrowsForAbstractMethodHandler()
+    public function testThrowsForAbstractMethodHandler(): void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Handler method "Mcp\Tests\Unit\Capability\Discovery\AbstractHandlerClass::abstractMethod" must be abstract.');
         HandlerResolver::resolve([AbstractHandlerClass::class, 'abstractMethod']);
     }
 
-    public function testResolvesClosuresWithDifferentSignatures()
+    public function testResolvesClosuresWithDifferentSignatures(): void
     {
         $noParams = static function () {
             return 'test';
@@ -152,7 +152,7 @@ public function testResolvesClosuresWithDifferentSignatures()
         $this->assertTrue(HandlerResolver::resolve($variadic)->isVariadic());
     }
 
-    public function testDistinguishesBetweenClosuresAndCallableArrays()
+    public function testDistinguishesBetweenClosuresAndCallableArrays(): void
     {
         $closure = static function () {
             return 'closure';