Parameter name binding

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## 3.2.1 under development
 
 - Bug #86: Fix crash when intersection types are used (@vjik)
+- Enh #87: Support parameter name bindings (@xepozz)
 
 ## 3.2.0 February 12, 2023
 

README.md

@@ -48,7 +48,7 @@ at the moment of obtaining a service instance or creating an object.
 
 #### `ArrayDefinition`
 
-Array definition allows describing a service or an object declaratively:
+`ArrayDefinition` describes a class declarative:
 
 ```php
 use \Yiisoft\Definitions\ArrayDefinition;
@@ -197,6 +197,38 @@ ContentNegotiator::class => [
 ],
 ```
 
+### Name binding
+
+Name binding is a way to bind a name to a definition. It is used to resolve a definition not by its class name but by a name.
+
+Set a definitions with a specific name. It may be typed or untyped reference like:
+1. `'$serviceName' => $definition`
+2. `Service::class . ' $serviceName' => $definition`
+
+```php
+return [
+   '$fileCache' => FileCache::class, // implements CacheInterface
+   '$redisCache' => RedisCache::class, // implements CacheInterface
+   CacheInterface::class . ' $memCache' => MemCache::class, // also implements CacheInterface
+]
+```
+
+So now you can resolve a definition by its name:
+
+```php
+class MyService
+{
+    public function __construct(
+        CacheInterface $memCache, // typed reference
+        $fileCache, // untyped reference
+        CacheInterface $redisCache, // typed reference to untyped definition
+    ) {
+        // ...
+    }
+
+}
+```
+
 ### Definition storage
 
 Definition storage could be used to hold and obtain definitions and check if a certain definition could be instantiated.

src/DefinitionStorage.php

@@ -96,12 +96,36 @@
      *
      * @throws CircularReferenceException
      */
-    private function isResolvable(string $id, array $building): bool
+    private function isResolvable(string $id, array $building, ?string $parameterName = null): bool
     {
         if (isset($this->definitions[$id])) {
             return true;
         }
 
+        if (
+            $parameterName !== null
+            && (
+                isset($this->definitions[$typedParameterName = $id . ' $' . $parameterName])
+                || isset($this->definitions[$typedParameterName = '$' . $parameterName])
+            )
+            && (!empty($buildingClass = array_key_last($building))) && class_exists($buildingClass)
+        ) {
+            $definition = $this->definitions[$buildingClass] ?? null;
+            $temporaryDefinition = ArrayDefinition::fromConfig([
+                ArrayDefinition::CLASS_NAME => $buildingClass,
+                ArrayDefinition::CONSTRUCTOR => [
+                    $parameterName => Reference::to($this->definitions[$typedParameterName]),
+                ],
+            ]);
+            if ($definition instanceof ArrayDefinition) {
+                $this->definitions[$buildingClass] = $definition->merge($temporaryDefinition);
+            } else {
+                $this->definitions[$buildingClass] = $temporaryDefinition;
+            }
+
+            return true;
+        }
+
         if ($this->useStrictMode || !class_exists($id)) {
             $this->buildStack += $building + [$id => 1];
             return false;
@@ -172,7 +196,7 @@
                             continue;
                         }
                         $unionTypes[] = $typeName;
-                        if ($this->isResolvable($typeName, $building)) {
+                        if ($this->isResolvable($typeName, $building, $parameter->getName())) {
                             $isUnionTypeResolvable = true;
                             /** @infection-ignore-all Mutation don't change behaviour, but degrade performance. */
                             break;
@@ -215,7 +239,7 @@
                     }
 
                     if (
-                        !$this->isResolvable($typeName, $building)
+                        !$this->isResolvable($typeName, $building, $parameter->getName())
                         && ($this->delegateContainer === null || !$this->delegateContainer->has($typeName))
                     ) {
                         $isResolvable = false;
@@ -227,7 +251,7 @@
             $this->buildStack += $building;
         }
 
-        if ($isResolvable) {
+        if ($isResolvable && !isset($this->definitions[$id])) {
             $this->definitions[$id] = $id;
         }
 

src/Helpers/Normalizer.php

@@ -53,6 +53,10 @@
             return $definition;
         }
 
+        if ($definition instanceof DefinitionInterface) {
+            return $definition;
+        }
+
         if (is_string($definition)) {
             // Current class
             if (
@@ -88,7 +92,7 @@
         }
 
         // Ready object
-        if (is_object($definition) && !($definition instanceof DefinitionInterface)) {
+        if (is_object($definition)) {
             return new ValueDefinition($definition);
         }