Create a basic version of the AutoImplementer project

[astaerk]

info: Initial commits were on #1 and #3, should have been on this issue number

• [x] create a new project containing a source generator
• [x] create build pipeline
• [x] publishable as NuGet package
• [x] AutoImplementInterfaceAttribute to mark interfaces that should be automatically implemented Currently there is no need to put that in a library that has to be deployed with the generated code. So just always generate it for every library using the source generator.
  • [x] AutoImplementInterfaceAttribute should be internal to not have conflicts using it in multiple projects, currently is public
• [x] support for basic auto-implemented properties
• [x] unit tests
• [x] support for attribute on each property to control some details (for now support ignoring a property and therefore force implementing it manually)
• [x] clarify if it would be better to mark the implementing classes for auto implementation
  • pros:
  • performance - source generator only has to process marked classes and not all classes that implement interfaces
  • it is more obvious on the implementing class, that some code is being generated
  • cons:
  • the motivation in the first place was to create interfaces you don't have to care about at the implementation side. One could also argue that having a class marked as partial is pretty obvious nowadays
  • it also could be an option to make that behavior configurable
• [x] attributes on properties are not automatically inherited from the interface. Therefore they have to be copied over
• [ ] detect manually implemented properties and skip them
• [x] support for required properties -> now in #2
• [ ] support for default implementations; implement a property on the class that redirects to the implementation on the interface
• [x] support for XML documentation (easiest would probably be to generate tag to inherit documentation from interface But not having this means that CS1591 warning about missing XML doc is showing up being a blocker for TreatWarningsAsErrors scenarios
• [ ] documentation

[Fasteroid]

clarify if it would be better to mark the implementing classes for auto implementation

This feels more intuitive to me. Also less chance to cause weird side effects. Imagine a dev that's unfamiliar with this project tags some existing interface with AutoImplement to use it in just one class—now every other class running that interface gets it auto-implemented! That seems like it could break something. Marking auto-implement on the class itself avoids that.

[astaerk]

yeah, that is exactly what I have in mind, too. On the other hand if manually implemented members will be detected and skipped nothing would break for existing implementations. And it is one thing less I have to do for all my implementing classes. Also this would mean you'd have to specify which interfaces should be automatically implemented on class level; because it's probably not all of them. This is why I somehow think about supporting both scenarios.

btw. I moved the attributes to namespace Basilisque.AutoImplementer.Annotations felt cleaner somehow

[astaerk]

I just pushed a breaking change in comparison to the first test versions. The implementing class now has to have a marker attribute for auto implementation to work: Basilisque.AutoImplementer.Annotations.AutoImplementInterfaces The attribute on the implemented interface is now optional.

Examples with explicitly stated interfaces on the class:

public interface IMyInterface
{ }

[Basilisque.AutoImplementer.Annotations.AutoImplementInterfaces<IMyInterface>()]
public class MyImplementation1 : IMyInterface
{ }

[Basilisque.AutoImplementer.Annotations.AutoImplementInterfaces(typeof(IMyInterface))]
public class MyImplementation2 : IMyInterface
{ }

[Basilisque.AutoImplementer.Annotations.AutoImplementInterfaces<IMyInterface>()]
public class MyImplementation3
{ }

[Basilisque.AutoImplementer.Annotations.AutoImplementInterfaces(typeof(IMyInterface))]
public class MyImplementation4
{ }

Example with implicitly interface discovery (implemented interfaces that are marked with an attribute):

[Basilisque.AutoImplementer.Annotations.AutoImplementInterface]
public interface IMyInterface1
{ }

public interface IMyInterface2
{ }

[Basilisque.AutoImplementer.Annotations.AutoImplementInterfaces]
public class MyImplementation : IMyInterface1, IMyInterface2
{ /* only IMyInterface1 will be auto implemented because IMyInterface2 is not marked with an attribute */ }

[Fasteroid]

Might be good to deprecate [Required] in favor of [AutoImplement(Required = true)]