Add Reflection information to Service Providers and Injection Attributes to DI

[alanondra]

Proposal inspired by PHP-DI. Typically if you want to resolve a specific instance of an object where multiple [named] instances can be resolved, you'd want to do something like this, or write a custom Provider to handle the mapping.

class MyController
{
	protected Guard $guard;

	// create as property
	public function __construct()
	{
		$this->guard = Auth::guard('web');
	}

	// or create in called method
	public function index()
	{
		$guard = Auth::guard('web');
	}	
}

class AuthProvider
{
	public function register()
	{
		$this->app
			->when(MyController::class)
			->needs(Guard::class)
			->give(function () {
				return Auth::guard('web');
			});
	}
}

My proposal is in two parts:

1. Since bind (and singleton, scoped, instance, etc.) is in most (?) cases used on some method (be it a named method or __construct), this would be facilitated by adding an instance of ReflectionParameter to the callback to resolve the instance. If there are cases where bind (and similar) do not refer to methods, perhaps introduce a method called resolvingParameter (name not important) which optionally returns an override (demonstrated below), using the default resolution method as a fallback.

2. Create Attributes to aid the Service Container in resolving specific instances:

• A general Attribute Inject (name not important) for referring to a named Container entry
• More specific Attributes for resolution of specific entries, for example GuardName (or similar) to resolve a specific Guard.

Here's an example for one of the specific instances, specifically GuardName - to use the current workflow of the AuthManager behaving as its own sort of container.

If you wanted to move away from it in the future, you could perhaps add Guards to the Container with the naming convention auth.guards.$name and add a method to the GuardName Attribute to get the formatted Container entry name, and then just use Inject.

#[Attribute]
class GuardName
{
	public function __construct(public readonly string $name)
	{
		//
	}
}

class MyController
{
	// constructor method
	public function __construct(
		#[GuardName('web')]
		protected Guard $guard
	) {
		//
	}

	// or called method
	public function index(
		#[GuardName('web')]
		Guard $guard
	) {
		//
	}
}

class AuthProvider extends ServiceProvider
{
	public function register()
	{
		$this->app->resolvingParameter(
			Guard::class,
			function (Application $app, ReflectionParameter $parameter) {
				$attributes = $parameter->getAttributes(GuardName::class);

				$attribute = Arr::first($attributes)?->newInstance();

				$entryName = $attribute->name ?? null;

				if (empty($entryName)) {
					return null;
				}

				/**
				 * @var \Illuminate\Auth\AuthManager
				 */
				$authManager = $app->get(AuthManager::class);

				return $authManager->guard($entryName);
			}
		);
	}
}