Cache constructor signatures in serviceCache for cross-request persistence

getCallableConstructorSignature() was the hottest injector code path
(8.1ms/req self CPU) but only cached results in a per-instance PHP
array that was rebuilt every request. The serviceCache (which can be
backed by a precomputed PHP file loaded via OPcache) was not consulted.

This meant the build step `service:precompute_service_cache` — which
calls warmCache for every container key — produced an effectively empty
cache file, since constructor signatures were never stored in it.

Changes:
- CachingClassInspector::getCallableConstructorSignature now checks
  serviceCache as an L2 cache behind the per-instance constructorCache.
  Only array results (valid signatures) are persisted; false/null
  (non-public/missing constructors) are kept in the per-instance cache
  only, since those classes are resolved from the container rather than
  auto-created.

Measured impact (30-request Excimer profiles on a storefront product
page, with the precomputed PHP file cache active):
- ClassInspector::getReflectionClass: 8.4 → 2.8 ms/req (-67%)
- Total injector self CPU: 18.1 → 12.4 ms/req (-31%)
- Total request CPU: 267 → 215 ms/req (-20%, t=-5.24)

Author: TomA-R

.phpstan/baseline.neon

@@ -30,12 +30,6 @@ parameters:
 			count: 1
 			path: ../src/Injector.php
 
-		-
-			message: '#^Method Bigcommerce\\Injector\\Injector\:\:buildParameterArray\(\) has InvalidArgumentException in PHPDoc @throws tag but it''s not thrown\.$#'
-			identifier: throws.unusedType
-			count: 1
-			path: ../src/Injector.php
-
 		-
 			message: '#^Method Bigcommerce\\Injector\\Injector\:\:buildParameterArray\(\) has parameter \$methodSignature with no value type specified in iterable type array\.$#'
 			identifier: missingType.iterableValue

src/Injector.php

@@ -198,7 +198,6 @@ public function canAutoCreate($className): bool
      * @return array
      * @throws InjectorInvocationException
      * @throws MissingRequiredParameterException
-     * @throws InvalidArgumentException
      * @throws ReflectionException
      */
     private function buildParameterArray($methodSignature, $providedParameters)

src/Reflection/CachingClassInspector.php

@@ -109,8 +109,19 @@ public function getCallableConstructorSignature(string $class): array|false|null
         if (isset($this->constructorCache[$class])) {
             return $this->constructorCache[$class][0];
         }
+
+        $key = "$class::__construct::callable_signature";
+        if ($this->serviceCache->has($key)) {
+            $result = $this->serviceCache->get($key);
+            $this->constructorCache[$class] = [$result];
+            return $result;
+        }
+
         $result = $this->classInspector->getCallableConstructorSignature($class);
         $this->constructorCache[$class] = [$result];
+        if (is_array($result)) {
+            $this->serviceCache->set($key, $result);
+        }
         return $result;
     }
 

tests/Reflection/CachingClassInspectorTest.php

@@ -29,6 +29,7 @@ protected function setUp(): void
         $serviceCache = $this->prophesize(ServiceCacheInterface::class);
         $serviceCache->set(Argument::cetera())->will(function ($arguments) use ($serviceCache) {
             $serviceCache->get($arguments[0])->willReturn($arguments[1]);
+            $serviceCache->has($arguments[0])->willReturn(true);
         });
         $this->serviceCache = $serviceCache;
         $this->classInspector = $this->prophesize(ClassInspector::class);
@@ -58,6 +59,7 @@ public function testWarmCachePopulatesCachesForNonConstructorMethod(): void
     public function testWarmCacheUsesOptimizedPathForConstructor(): void
     {
         $signature = [['name' => 'dependency', 'type' => 'SomeClass']];
+        $this->serviceCache->has(Argument::cetera())->willReturn(false);
         $this->classInspector->getCallableConstructorSignature(DummyDependency::class)
             ->willReturn($signature);
 
@@ -68,9 +70,25 @@ public function testWarmCacheUsesOptimizedPathForConstructor(): void
         $this->classInspector->getMethodSignature(Argument::cetera())->shouldNotHaveBeenCalled();
     }
 
+    public function testWarmCachePopulatesServiceCacheForConstructor(): void
+    {
+        $signature = [['name' => 'dependency', 'type' => 'SomeClass']];
+        $this->serviceCache->has(Argument::cetera())->willReturn(false);
+        $this->classInspector->getCallableConstructorSignature(DummyDependency::class)
+            ->willReturn($signature);
+
+        $this->subject->warmCache(DummyDependency::class, '__construct');
+
+        $this->serviceCache->set(
+            "Tests\Dummy\DummyDependency::__construct::callable_signature",
+            $signature
+        )->shouldHaveBeenCalled();
+    }
+
     public function testGetCallableConstructorSignatureCachesResult(): void
     {
         $signature = [['name' => 'dependency', 'type' => 'SomeClass']];
+        $this->serviceCache->has(Argument::cetera())->willReturn(false);
         $this->classInspector->getCallableConstructorSignature(DummyDependency::class)
             ->willReturn($signature)
             ->shouldBeCalledOnce();
@@ -82,8 +100,22 @@ public function testGetCallableConstructorSignatureCachesResult(): void
         $this->assertEquals($signature, $result2);
     }
 
+    public function testGetCallableConstructorSignatureUsesServiceCacheOnL1Miss(): void
+    {
+        $signature = [['name' => 'dependency', 'type' => 'SomeClass']];
+        $key = "Tests\Dummy\DummyDependency::__construct::callable_signature";
+        $this->serviceCache->has($key)->willReturn(true);
+        $this->serviceCache->get($key)->willReturn($signature);
+
+        $result = $this->subject->getCallableConstructorSignature(DummyDependency::class);
+
+        $this->assertEquals($signature, $result);
+        $this->classInspector->getCallableConstructorSignature(Argument::cetera())->shouldNotHaveBeenCalled();
+    }
+
     public function testGetCallableConstructorSignatureReturnsNullForNoConstructor(): void
     {
+        $this->serviceCache->has(Argument::cetera())->willReturn(false);
         $this->classInspector->getCallableConstructorSignature(DummyDependency::class)
             ->willReturn(null);
 
@@ -94,6 +126,7 @@ public function testGetCallableConstructorSignatureReturnsNullForNoConstructor()
 
     public function testGetCallableConstructorSignatureReturnsFalseForNonPublicConstructor(): void
     {
+        $this->serviceCache->has(Argument::cetera())->willReturn(false);
         $this->classInspector->getCallableConstructorSignature(DummyDependency::class)
             ->willReturn(false);