replace annotation with attributes

[arhimede]

maybe we can remove the dependency to doctrine-annotation ?

[alexmerlin]

@arhimede @MarioRadu I have a question:

What do you think, would the below help or add an unnecessary complexity?

Let's consider the following code:

class Example
{
	#[Inject(
		Depencency1::class, 
		Depencency2::class,
	)]
	public function __construct(
		protected Depencency1 $dependency1,
		protected Depencency2 $dependency2,
	) {
		...
	}
}

I'm thinking about a more flexible way of injecting the dependencies into classes.
If, there is an Inject attribute on the Example class, load ONLY the dependencies specified in the attribute and ignore the constructor parameters. (basically, the current implementation)

But, if there is no Inject attribute specified, look at the constructor and extract dependencies from there.
This way, developers would not need to duplicate the list of dependencies in both the Inject attribute and the class constructor.

Both the Inject-only and the more flexible solution would need only one

Example::class => AttributeServiceFactory::class

entry in the module's ConfigProvider, so having both would not duplicate functionality.

[marioradu05]

The second option sounds interesting, this looks like the autowiring feature from the other frameworks.
While this solution would help us not duplicate the dependencies and result in a more clean and readable code I would say that at least we should let the programmer mark the class as injectable using the Inject attribute, without the need to specify the dependencies. So a injectable class could look like this :

class Example
{
	#[Inject]
	public function __construct(
		protected Depencency1 $dependency1,
		protected Depencency2 $dependency2,
	) {
		...
	}
}

The main concern when injecting dependencies is infinite loops, so by manually marking the class as injectable you ensure the programmer saw at least one time the dependencies and took action if needed.

[alexmerlin]

@arhimede @MarioRadu
Unfortunately, using the #[Inject] attribute without specifying dependencies as parameters is not an option because it does not allow injecting sub-items of the main $config array.
Up to the current version of dot-annotated-service, we could use "config.example" that would internally inject only $config['example'].
Switching to the #[Inject] attribute + read constructor parameters method would not allow this anymore.

Therefore - even though we keep duplicating the dependencies - we need to use the already-known structure, but with attributes instead of annotations:

class Example
{
  #[Inject(
    Service::class,
    "config.example"
  )]
  public function __construct(
    protected Service $service,
    protected array $config,
  )
}

[alexmerlin]

Implemented in #36