[Proposal]: Make Default parameter value providers extensible

[Nintynuts]

💡 Problem

C# lacks flexibility in defining default method parameter values based on compile-time context. The current system, limited to literals or specific attributes, restricts language evolution and leads to boilerplate for advanced scenarios like context-aware defaults for generic types.

🌟 Proposed Solution

I propose adding a Roslyn extensibility point: an IDefaultValueProvider interface and a DefaultArgumentBindingContext. This allows developers to inject custom logic into the compiler's binding phase, providing rich, context-aware defaults and diagnostics for optional parameters.

🧩 Public API

The following public types would be introduced:

1. DefaultValueKind Enum

/// <summary>  
/// Specifies the kind of default value information being provided by an <see cref="IDefaultValueProvider"/>.  
/// This guides the compiler on how to interpret and bind the supplied default value.  
/// </summary>  
public enum DefaultValueKind  
{  
    /// <summary>  
    /// The default value should be the result of the <c>default(T)</c> expression for the parameter's type.  
    /// This is often the default fallback if a custom provider cannot determine a more specific value.  
    /// The compiler will generate the appropriate zero-initialization for value types or null for reference types.  
    /// </summary>  
    DefaultExpression,

    /// <summary>  
    /// The default value is a compile-time constant literal (e.g., "hello", 123, null).  
    /// The <see cref="DefaultValueInfo.LiteralValue"/> property will contain the literal value.  
    /// </summary>  
    Literal,

    /// <summary>  
    /// The default value is a string representation of a C# expression that the compiler should  
    /// parse, bind, and evaluate at the call site. The <see cref="DefaultValueInfo.ExpressionText"/>  
    /// property will contain the string representing the expression.  
    /// </summary>  
    CustomExpression  
}

2. DefaultValueInfo Struct

Static factory methods omitted for brevity.

using Microsoft.CodeAnalysis;

/// <summary>  
/// Encapsulates the information about a default value provided by an <see cref="IDefaultValueProvider"/>.  
/// This struct acts as a public-facing data transfer object for default values.  
/// </summary>  
public readonly struct DefaultValueInfo  
{  
    /// <summary>  
    /// Gets the kind of default value. This property determines how the other properties are interpreted.  
    /// </summary>  
    public DefaultValueKind Kind { get; }

    /// <summary>  
    /// Gets the literal constant value if <see cref="Kind"/> is <see cref="DefaultValueKind.Literal"/>.  
    /// This can be any C# constant type (e.g., <c>int</c>, <c>string</c>, <c>bool</c>, <c>null</c>).  
    /// Otherwise, this property is <c>null</c>.  
    /// </summary>  
    public object? LiteralValue { get; }

    /// <summary>  
    /// Gets the string representation of the expression if <see cref="Kind"/> is <see cref="DefaultValueKind.CustomExpression"/>.  
    /// Otherwise, this property is <c>null</c>.  
    /// </summary>  
    public string? ExpressionText { get; }

    /// <summary>  
    /// Initializes a new instance of the <see cref="DefaultValueInfo"/> struct.  
    /// </summary>  
    /// <param name="kind">The kind of default value.</param>  
    /// <param name="literalValue">The literal value for <see cref="DefaultValueKind.Literal"/>.</param>  
    /// <param name="expressionText">The expression text for <see cref="DefaultValueKind.CustomExpression"/>.</param>  
    private DefaultValueInfo(DefaultValueKind kind, object? literalValue, string? expressionText)  
    {  
        Kind = kind;  
        LiteralValue = literalValue;  
        ExpressionText = expressionText;  
    }

    /* static Factory methods to ensure correct initialisation */
}

3. DefaultArgumentBindingContext struct

Akin to other compiler extensions, a context is provided to access required data.

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Collections.Immutable;
using System;

/// <summary>  
/// Provides essential context to default argument value providers during compilation.  
/// This abstract class defines the public contract for accessing compiler information and services.  
/// The concrete implementation will be provided internally by the C# compiler.  
/// </summary>  
public readonly struct DefaultArgumentBindingContext  
{  
    /// <summary>  
    /// Gets the current <see cref="CSharpCompilation"/> instance.  
    /// This provides access to the overall compilation settings, references, and symbols.  
    /// </summary>  
    public CSharpCompilation Compilation { get; }

    /// <summary>  
    /// Gets the <see cref="SemanticModel"/> for the syntax tree containing the <see cref="InvocationSyntax"/>.  
    /// This is crucial for performing rich semantic analysis (e.g., getting symbol info for nodes,  
    /// type information, nullability analysis) at the invocation site.  
    /// </summary>  
    public SemanticModel SemanticModel { get; }

    /// <summary>  
    /// Gets the <see cref="SyntaxNode"/> representing the method invocation or object creation  
    /// where the default argument is being bound. This provides the syntactic context about the call site.  
    /// Access other arguments via its <see cref="SyntaxNode.ChildNodes"/> or specific properties  
    /// of derived types (e.g., <see cref="InvocationExpressionSyntax.ArgumentList"/>).  
    /// </summary>  
    public SyntaxNode InvocationSyntax { get; }

    /// <summary>  
    /// Retrieves an <see cref="ITypeSymbol"/> for a well-known <see cref="SpecialType"/>  
    /// (e.g., <c>System.String</c>, <c>System.Int32</c>).  
    /// This ensures providers get type symbols consistently with the compiler's own lookup.  
    /// </summary>  
    /// <param name="specialType">The special type enum value.</param>  
    /// <param name="diagnostics">A collection to report diagnostics if the special type cannot be found.  
    /// (Note: In a real implementation, this might be a separate diagnostic bag for internal use.)</param>  
    /// <param name="syntax">The syntax node associated with the request (for diagnostic location).</param>  
    /// <returns>The <see cref="ITypeSymbol"/> for the requested special type.</returns>  
    public ITypeSymbol GetSpecialType(SpecialType specialType, ImmutableArray<Diagnostic> diagnostics, SyntaxNode syntax) {...}

    /// <summary>  
    /// Allows the provider to report a <see cref="Diagnostic"/> (e.g., a warning or error) during compilation.  
    /// </summary>  
    /// <param name="diagnostic">The diagnostic to report.</param>  
    public void ReportDiagnostic(Diagnostic diagnostic)  {...}

    /* Internal constructor */
}

4. IDefaultValueProvider Interface

using Microsoft.CodeAnalysis; // IParameterSymbol, ITypeSymbol

/// <summary>  
/// Represents a provider that can supply custom default values for optional method parameters  
/// during the C# compilation process. Implementations of this interface are discovered  
/// and integrated by a Roslyn Source Generator.  
/// </summary>  
public interface IDefaultValueProvider  
{  
    /// <summary>  
    /// Determines if this provider can supply a default value for the given parameter in the current context.  
    /// </summary>  
    /// <param name="context">The <see cref="DefaultArgumentBindingContext"/> providing compiler information  
    /// relevant to the current binding operation.</param>  
    /// <param name="parameter">The <see cref="IParameterSymbol"/> for which a default value is needed.</param>  
    /// <returns><c>true</c> if this provider can supply the default value for the specified parameter;  
    /// otherwise, <c>false</c>.</returns>  
    bool Applies(DefaultArgumentBindingContext context, IParameterSymbol parameter);

    /// <summary>  
    /// Provides the default value information for the parameter. The transformation of this information  
    /// into a compiler-internal <c>BoundExpression</c> and subsequent type conversions are handled  
    /// internally by the C# compiler.  
    /// </summary>  
    /// <param name="context">The <see cref="DefaultArgumentBindingContext"/> providing compiler information.</param>  
    /// <param name="parameter">The <see cref="IParameterSymbol"/> for which the default value is needed.</param>  
    /// <param name="parameterType">The <see cref="ITypeSymbol"/> representing the actual, substituted type of the parameter  
    /// at the call site. For generic methods, this will be the concrete type argument (e.g., <c>string?</c> if <c>T</c> was substituted with <c>string?</c>),  
    /// whereas <paramref name="parameter.Type"/> would be the generic type parameter (<c>T</c>).</param>  
    /// <returns>A <see cref="DefaultValueInfo"/> struct representing the default value to be used.</returns>  
    DefaultValueInfo ProvideValue(DefaultArgumentBindingContext context, IParameterSymbol parameter, ITypeSymbol parameterType);  
}

📦 How It Would Be Used

1. Develop a Custom Provider: Developers create a .NET Standard library implementing IDefaultValueProvider. The provider's Applies method determines if it's relevant for a given parameter, and ProvideValue returns the desired default.
2. Integrate via Roslyn Component: Roslyn comonent system scans the compilation for IDefaultValueProvider implementations (as with source generators or analysers) and registers them with the C# compiler.
3. Compiler Integration: During method or constructor binding, the C# compiler queries the registered providers. A singular provider whose Applies method returns true will have its ProvideValue method invoked. The DefaultValueInfo returned then guides the compiler in generating the final default argument expression.
4. Conflict Resolution: If multiple providers could apply to the same binding the compilation fails, but a project property could provide a sparse list of qualified provider type names that could be used to determine precedent if this happens. Ideally this would not happen as each provider should be looking for a different attribute, but there may be desire for overrides.

🏆 Benefits

• Extensible Default Logic: Enables defining default values based on complex, compile-time context.
• Enhanced Compile-Time Safety: Allows custom providers to emit targeted diagnostics for specific default value scenarios.
• Reduced Boilerplate: Centralizes and manages sophisticated default value logic within an extensible framework.
• Minimal Public API: A lean context object focuses on essential compiler interactions for powerful extensibility.

This proposal offers a powerful and flexible way to extend the C# compiler, leveraging the strengths of Roslyn's extensibility model.

[colejohnson66]

Do you have any examples where this would be useful?

[Nintynuts]

The use case I had in mind is capturing reference type nullability in generics, but you could also use it to capture the target variable in an assignment, or automatically include a contextual variable like a cancellation token. It seems like there's potentially endless possibilities.