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
• [ ] support for attribute on each property to control some details (for now support ignoring a property and therefore force implementing it manually)
• [ ] 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
• [ ] detect manually implemented properties and skip them
• [ ] 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