Swapping implementations of core contracts

[jrmajor]

Converted from issue #37812 to discussion

TL;DR

I've run into this problem when developing a package that replaces the default Laravel translator with a custom one (https://github.com/jrmajor/laravel-fluent). I can't figure out how to correctly register it in service container so that:

use Illuminate\Contracts\Translation\Translator as TranslatorContract;
use Illuminate\Translation\Translator as BaseTranslator;
use Major\Fluent\Laravel\FluentTranslator;

app('translator')              instanceof FluentTranslator::class;
app(TranslatorContract::class) instanceof FluentTranslator::class;
app(BaseTranslator::class)     instanceof BaseTranslator::class;
app(FluentTranslator::class)   instanceof FluentTranslator::class;

Introduction

Consider the following classes:

interface ComponentContract { }
class LaravelComponent implements ComponentContract { }
class UserlandComponent implements ComponentContract { }

Laravel components are registered in service container by simple string keys (app('component') returns instance of LaravelComponent). This happens in ComponentServiceProvider:

$app->singleton('component', fn () => new LaravelComponent());

Both ComponentContract and LaravelComponent are then registered as aliases to component. This happens in Illuminate\Foundation\Application::registerCoreContainerAliases():

$app->alias('component', ComponentContract::class);
$app->alias('component', LaravelComponent::class);

Edit: Actually, aliases are registered before service providers are loaded.

Description

I've run into this problem when developing a package that replaces the default Laravel translator with a custom one (https://github.com/jrmajor/laravel-fluent).

Using the example from the introduction, I want to replace LaravelComponent with UserlandComponent in my application. It should work like this:

app('component')              instanceof UserlandComponent::class;
app(ComponentContract::class) instanceof UserlandComponent::class;
app(LaravelComponent::class)  instanceof LaravelComponent::class;
app(UserlandComponent::class) instanceof UserlandComponent::class;

I've managed to accomplish this by registering my component like that:

$laravelComponent = app(LaravelComponent::class);

$app->singleton(UserlandComponent::class, fn () => new UserlandComponent());
$app->bind(ComponentContract::class, UserlandComponent::class);
$app->alias(ComponentContract::class, 'component');
$app->instance(LaravelComponent::class, $laravelComponent);

But this can’t be done in register(), because LaravelComponent is not registered yet. It works only when it’s done in boot().

To make it work in register() method, I would have to copy all the logic for building LaravelComponent from Laravel’s service provider and put it into the last line of the above code.

Alternatively, I can register it like it’s registered by Laravel:

$app->singleton('component', fn () => new UserlandComponent());
$app->alias('component', UserlandComponent::class);

But it makes it impossible to resolve LaravelComponent from the service container (it would always return UserlandComponent), which would break dependency injection for a class with type hinted LaravelComponent.

Edit: Container::extend() has the same problem.

Possible solution?

If Laravel registered it’s core services like this:

$app->singleton(LaravelComponent::class, fn () => new LaravelComponent());
$app->bind(ComponentContract::class, LaravelComponent::class);
$app->alias(ComponentContract::class, 'component');

These two lines in service provider would be enough to make everything work as expected:

$app->singleton(UserlandComponent::class, fn () => new UserlandComponent());
$app->bind(ComponentContract::class, UserlandComponent::class);

The way Laravel does it currently seems strange to me. Is there any reason it's done like that?