Merge pull request #43 from bigcommerce/perf/constructor-signature-caching

Cache constructor signatures in serviceCache

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);