Shared code for source generators

[bencyoung-Fignum]

Source generators are super powerful, but at the moment require a large amount of work at the syntax level to be able to read and then generate the required code.

I think a lot of cases will end up duplicating this code but with the desire of pretty much doing the same things over and over again, especially things like serializers. Are there any plans to export a fast source generated variant of reflection that can be used by multiple reflection systems? Even better would be a simple attribute that then accelerates the current reflection APIs by producing concrete implementation for that type but I can see that those may not be optimized for performance...

Things like System.Text.Json could then reuse the common generated API but so could others, in the end reducing the amount of code that needs to be generated

For instance we have a custom value system that we want to be convertable to .NET objects but writing a source generator would be a huge amount of work and doing it via reflection is likely to be slow!

[jkotas]

For existing reflection APIs, there is opportunity to improve performance. .NET 7 had improvements in this space (https://devblogs.microsoft.com/dotnet/performance_improvements_in_net_7/#reflection) and some more are planned for .NET 7.

The performance ceiling of the existing reflection APIs is given by the API shape - the reflection APIs take and return boxed values, perform a lot of validations and conversions, etc. Reflection is always going to be significantly slower than straight-line core. Source generators cannot really fix that.

System.Text.Json could then reuse the common generated API

What would the common generated API be? There is a lot of System.Text.Json specific details in the code that the System.Text.Json generates today.

[bencyoung-Fignum]

Thanks for the reply!

I agree about the current API shape not being suitable for high perf API (although in the past we've used the emit IL approach to make the property setters and getters about 10x faster). I'm also not sure what the common API would be or if it would be at the source gen level or the generated API level. I do know there's a huge amount of stuff that System.Text.Json uses that any other accelerated source gen based serialization will also want to do so I think there must be some sharing possible, however it may be a case of "write it x times and see what common shapes occur". I.e. it's not possible to know upfront what's useful to reuse.

[bencyoung-Fignum]

I do think a lot of reflection/serialization APIs do bottleneck on pretty much the same things so being able to auto generate

Action<ThisType, T> GetPropertySetter<T>(string propertyName)
{
  switch(propertyName)
  {
    case "MyIntProperty": return (t, value) => t.intProperty = (int)(object)value;
   ...
  }
}

and the non caching equivalents would likely accelerate 90% of cases. If you could add an interface to the type and then detect it in various reflection use cases (DI, config, serialization, relfection) then a lot could gain performance relatively automatically.