C# source generator that creates combinatorial extension method overloads by treating a parameter window as optional and emitting legal, unique subsequences.
A C# source generator that creates extension overloads by treating a selected parameter window as optional and emitting legal, unique subsequences. It supports matchers, bucketized output, visibility overrides, subsequence strategies, and generic substitution via SupplyParameterType.
Route generated overloads into a specific static partial class:
public static partial class MyBucket
{
}
[OverloadGenerationOptions(BucketType = typeof(MyBucket))]
[GenerateOverloads(Begin = nameof(optionalA))]
public void Configure(int required, string? optionalA, bool optionalB) { }
Output:
public static partial class MyBucket
{
public static void Configure(this /* target type */ source, int required) =>
source.Configure(required, optionalA: default(string), optionalB: default(bool));
}
9) SupplyParameterType (Generic Substitution)
Replace method type parameters with concrete types in generated overloads and invocations.
public sealed class Constraint { }
public interface IService<T> { }
public sealed class Api
{
[GenerateOverloads(nameof(optionalObject))]
[SupplyParameterType(nameof(TConstraint), typeof(Constraint))]
public void Use<TConstraint>(IService<TConstraint>? service, object? optionalObject) { }
}
Output:
public static class MethodOverloads
{
public static void Use(this Api source, IService<Constraint>? service) =>
source.Use<Constraint>(service, default(object?));
}
If only some method type parameters are supplied, the overload stays generic for the remaining ones.
10) Generic Containing Types
Containing type type parameters and constraints are preserved on generated overloads.
public sealed class Container<T> where T : class, new()
{
[GenerateOverloads(nameof(optionalObject))]
public void Create(T value, object? optionalObject) { }
}
Generated overloads keep T and its constraints.
MSBuild Options
Emit attributes only (skip generation and diagnostics):
