better handling of classname

[azjezz]

The current classname is a bit broken, and using it in a more than string-class-name-representation is quite hard if not impossible in some cases ( see #8772 )

Another issue is that class name cannot be enforced to be a real class name, an interface name, a trait name, an abstract class name .. etc.

This forces the developer to create a dummy interface to enforce against, even if the interface has no methods.

The case for dependency injection

In the past 2 weeks, I have been working on a DI component for the @nuxed Framework.

the current service container interface looks like this:

namespace Nuxed\DependencyInjection;

/**
 * Describes the interface of a container that exposes methods to read its entries.
 */
interface IServiceContainer {
  /**
   * Finds services of the container by their tag and return all of them.
   *
   * @throws Exception\ContainerException Error while retrieving the services.
   */
  public function tagged<<<__Enforceable>> reify T>(
    classname<T> $tag,
  ): Container<T>;

  /**
  * Finds a service of the container by its type and returns it.
  *
  * @throws Exception\NotFoundException  Service is not managed by the container.
  * @throws Exception\ContainerException Error while retrieving the service.
  */
  public function get<<<__Enforceable>> reify T>(classname<T> $service): T;

  /**
   * Returns true if the container contains the service.
   * Returns false otherwise.
   *
   * `has<T>($service)` returning true does not mean that `get<T>($service)` will not throw an exception.
   * It does however mean that `get($id)` will not throw a `Exception\NotFoundException`.
   */
  public function has<<<__Enforceable>> reify T>(classname<T> $service): bool;
}

what I want to focus on is the tagged method, this method is supposed to return all implementations tagged with a specific interface, however, currently is possible to tag using any class name, that is being an abstract class or a non-abstract base class, but I want to forbid this behavior, making it impossible to use anything but an interface as a tag, this will promote composition over inheritance.

the container builder which allows you to add service definitions and tag services with a specific interface looks like this:

namespace Nuxed\DependencyInjection;

use namespace HH\Lib\{C, Dict, Str};
use namespace Nuxed\Configuration;

final class ContainerBuilder {
  private dict<string, mixed> $definitions = dict[];

  public function __construct(
    private Configuration\IConfiguration $configuration,
  ) {}

  public function register(IServiceProvider $provider): this {
    $provider->register($this, $this->configuration);

    return $this;
  }

  public function add<<<__Enforceable>> reify T>(
    classname<T> $service,
    IFactory<T> $factory,
    bool $shared = true,
  ): this {
    $this->addDefinition<T>(
      new ServiceDefinition<T>($service, $factory, $shared),
    );

    return $this;
  }

  public function tag<
    <<__Enforceable>> reify TT,
    <<__Enforceable>> reify TS as TT,
  >(classname<TT> $tag, classname<TS> $service): this {
    $definition = $this->getDefinition<TS>($service);
    $definition->addTag<TT>($tag);

    return $this;
  }

  public function inflect<<<__Enforceable>> reify T>(
    classname<T> $service,
    IInflector<T> $inflector,
  ): this {
    $definition = $this->getDefinition<T>($service);
    $definition->inflect($inflector);

    return $this;
  }

  private function addDefinition<<<__Enforceable>> reify T>(
    ServiceDefinition<T> $definition,
  ): void {
    $this->definitions[$definition->getType()] = $definition;
  }

  private function getDefinition<<<__Enforceable>> reify T>(
    classname<T> $service,
  ): ServiceDefinition<T> {
    if (C\contains_key($this->definitions, $service)) {
      return $this->definitions[$service] as ServiceDefinition<T>;
    }

    throw new Exception\NotFoundException(Str\format(
      'Container builder doesn\'t contain definition for service (%s).',
      $service,
    ));
  }

  public function build(
    Container<IServiceContainer> $delegates = vec[],
  ): IServiceContainer {
    $definitions = Dict\map(
      $this->definitions,
      ($definition) ==> {
        $definition as ServiceDefinition<_>;
        return clone $definition;
      },
    );

    return new ServiceContainer(
      /* HH_IGNORE_ERROR[4110] */
      $definitions,
      $delegates,
    );
  }
}

Ignore the potential issue that is the result of Hack not allowing properties to have types such as ServiceDefinition<_>, therefore mixed is used...

as you can see in the tag method, as long as the tag is a subtype of the service type, things will work.

this can be enforced at runtime using reflections or interface_exists, however, it is also possible to determine this statically if Hack had a type to represent interfaces.

---

Another issue ( ref #8461 ) is that hack lacks the type object, making it impossible to use T::class, unless the generic parameter T is of a specific class, therefor, @nuxed is forced to require classname<T> as an argument, instead of using T::class.

---

Another issue is that T ( even when reified ) doesn't hold on to its own generic parameters.

function print_it<<<__Enfoceable>> reify T>(): void {
  $name = T::class;
  print((string) $name);
}

print_it<Foo<string>>(); // expected: "Foo<string>", current: "Foo"
print_it<Foo<string>>(); // expected: "Foo<string>", current: "Foo"

---

Solution

I'm not really sure what the best solution for this is, let's discuss it :)

[azjezz]

another case i just faced ...

namespace Nuxed\DependencyInjection\Processor;

use namespace Nuxed\DependencyInjection;
use namespace Nuxed\DependencyInjection\Inflector;

final class ServiceContainerAwareProcessor implements IProcessor {
  /**
   * Process the given service definition and return the
   * modified service definition.
   */
  public function process<<<__Enforceable>> reify T>(
    DependencyInjection\ServiceDefinition<T> $definition,
  ): DependencyInjection\ServiceDefinition<T> {
    if (
      \is_a(
        $definition->getType(), // classname<T>
        DependencyInjection\IServiceContainerAware::class,
        true,
      )
    ) {
      return $definition->withInflector(
        /* HH_IGNORE_ERROR[4110] - hack can't understand this, but it is valid. */
        new Inflector\ServiceContainerAwareInflector(),
      );
    }

    return $definition;
  }
}