Request: A plugin system for builders

Request

I'd like to have some kind of plugin system for builders. On a high level, third-party packages should be able to "inject" code into a builder, so that its behavior can be tailored for specific use-cases that the build author can't or doesn't want to support.

More concise, it could allow a builder to declare abstract interfaces for it to consume. Other packages can announce that they provide an implementation for those interfaces. During a build, the builder can request a list of all implementations from the build system and call methods on them. Service discovery could happen statically, say based on build.yaml content while generating the build script.

Motivation

I believe that builder authors can benefit from a plugin system in different ways. First, it helps reducing complexity with better modularization: Builders usually have to deal with a wide-range of requirements related to their domain, which introduces complexity. Since most builders generate Dart code directly, there's little chance of modularizing that across different packages. By implementing only the core logic and delegating further tasks to different packages via interfaces, builders become easier to write and maintain. Further, since those interfaces are public and can be implemented by everyone, users can tailor existing builders to very specific scenarios instead of writing their own builders from scratch.

Most other build systems support this kind of communication in some way. For instance, different Gradle plugins can communicate with each other. This is commonly used for compile-time code modification, e.g. with Kotlin compiler plugins.

Example use-cases

Builders related to serialization could expose an api to support more advanced types
build_*_compilers:
- Could expose an api to perform front-end transformations, like thetrack-widget-creation logic from Flutter
- Hypothetically, it could even support other frontends or different languages that compile to Kernel
Personally, I maintain a builder generating Dart apis by performing static analysis on sql statements. That itself is complicated enough, but some users would like to have a full-blown ORM built on top of that. It would be great if such features could be provided in another package (with independent versioning), plugins could enable that.

Possible api

Finding implementations of a declared interface should be easy to understand and debug. So a good candidate is static resolution while generating the build script. To make that feasible, interfaces could be declared in build.yaml:

# pkg:my_generator/build.yaml
builders:
  my_generator:
    import: "package:my_generator/build.dart"
    builder_factories: ["myBuilder"]
    build_extensions: {".dart": [".foo.g.part"]}
    consumes_interfaces:
     - my_generator|type_provider
    # ...
interfaces:
  type_provider:
    import: 'package:my_generator/interface.dart'
    class_name: 'TypeProvider'

Another package, which doesn't have to declare a builder on its own, could then mark that it provides an implementation for that interface:

# pkg:supplement/build.yaml
implementations:
  - interface: my_generator|type_provider
    import: 'package:supplement/impl.dart'
    factory: 'additionalTypeProvider'

Now, if a build ran on a user package that depends on both my_generator and supplement, the builder should be able to obtain the implementation from the other package:

// builder in the my_generator package
Future build(BuildStep step) {
  final List providers = step.implementationsOf('my_generator|type_provider');
  // providers should now contain the implementation defined in the supplementary package
}

Having the actual instance available, the builder can now use it.

I know that this is a rather large change, and it's completely understandable if this isn't a priority for the Dart team. I would love to see some kind of service discovery or plugins for builders, so I'd be glad to help implementing this. All kinds of feedback on the overall idea and the api are greatly appreciated of course.

dart-lang / build