Part 7: Catching Misuse at Edit-Time📋

namespace FrenchExDev.Net.Traefik.Bundle.SourceGenerator.Analyzers;

internal static class TraefikDiagnostics
{
    private const string Category = "TraefikBundle";

    public static readonly DiagnosticDescriptor MultipleBranchesSet = new(
        id: "TFK001",
        title: "Discriminated union has more than one branch set",
        messageFormat: "'{0}' is a Traefik discriminated union — exactly one branch must be set, but the initializer assigns {1}",
        category: Category,
        defaultSeverity: DiagnosticSeverity.Warning,
        isEnabledByDefault: true,
        description: "Traefik flat unions (e.g. http middleware, http service) silently reject configurations with more than one branch populated.");

    // TFK002 reserved for "dangling router → service reference" — see PLAN.md.
    // Implementing it well requires walking the assembled config graph; today's
    // shape doesn't make this cheap to detect across files, so the rule is
    // documented but not yet active.

    // TFK003 ("use of deprecated Traefik property") is intentionally subsumed
    // by the standard CS0618 warning. The model emitter stamps [Obsolete] on
    // every property where the schema sets `deprecated: true`, so the C#
    // compiler reports it natively without a custom analyzer.

    public static readonly DiagnosticDescriptor NoSchemasFound = new(
        id: "TFK004",
        title: "No Traefik schemas wired as AdditionalFiles",
        messageFormat: "The Traefik bundle source generator did not find any 'traefik-v3-*.json' AdditionalFiles. No models will be generated.",
        category: Category,
        defaultSeverity: DiagnosticSeverity.Warning,
        isEnabledByDefault: true,
        description: "Add the embedded schemas to your csproj as <AdditionalFiles> for the generator to produce models.");
}

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public sealed class DiscriminatedUnionAnalyzer : DiagnosticAnalyzer
{
    private const string AttributeFullName =
        "FrenchExDev.Net.Traefik.Bundle.Attributes.TraefikDiscriminatedUnionAttribute";

    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
        ImmutableArray.Create(TraefikDiagnostics.MultipleBranchesSet);

    public override void Initialize(AnalysisContext context)
    {
        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
        context.EnableConcurrentExecution();
        context.RegisterSyntaxNodeAction(AnalyzeObjectCreation,         SyntaxKind.ObjectCreationExpression);
        context.RegisterSyntaxNodeAction(AnalyzeImplicitObjectCreation, SyntaxKind.ImplicitObjectCreationExpression);
    }

    private static void AnalyzeObjectCreation(SyntaxNodeAnalysisContext ctx)
    {
        var node = (ObjectCreationExpressionSyntax)ctx.Node;
        AnalyzeInitializer(ctx, node.Initializer, node);
    }

    private static void AnalyzeImplicitObjectCreation(SyntaxNodeAnalysisContext ctx)
    {
        var node = (ImplicitObjectCreationExpressionSyntax)ctx.Node;
        AnalyzeInitializer(ctx, node.Initializer, node);
    }

    private static void AnalyzeInitializer(
        SyntaxNodeAnalysisContext ctx,
        InitializerExpressionSyntax? initializer,
        ExpressionSyntax creationNode)
    {
        if (initializer is null) return;
        if (initializer.Expressions.Count < 2) return;

        var typeInfo = ctx.SemanticModel.GetTypeInfo(creationNode, ctx.CancellationToken);
        var type = typeInfo.Type;
        if (type is null) return;
        if (!HasDiscriminatedUnionAttribute(type)) return;

        // Count how many branch property assignments are *not* explicitly null.
        var setBranches = 0;
        var firstSetName = (string?)null;
        var secondSetSpan = (Location?)null;

        foreach (var expr in initializer.Expressions)
        {
            if (expr is not AssignmentExpressionSyntax assignment) continue;
            if (assignment.Left is not IdentifierNameSyntax id) continue;
            // null literal RHS doesn't count as a branch being set.
            if (assignment.Right is LiteralExpressionSyntax lit &&
                lit.IsKind(SyntaxKind.NullLiteralExpression))
            {
                continue;
            }

            setBranches++;
            if (setBranches == 1)
            {
                firstSetName = id.Identifier.Text;
            }
            else if (setBranches == 2)
            {
                secondSetSpan = assignment.GetLocation();
            }
        }

        if (setBranches > 1 && secondSetSpan is not null)
        {
            ctx.ReportDiagnostic(Diagnostic.Create(
                TraefikDiagnostics.MultipleBranchesSet,
                secondSetSpan,
                type.Name,
                setBranches));
        }
    }

    private static bool HasDiscriminatedUnionAttribute(ITypeSymbol type)
    {
        foreach (var attr in type.GetAttributes())
        {
            var attrClass = attr.AttributeClass;
            if (attrClass is null) continue;
            if (attrClass.ToDisplayString() == AttributeFullName) return true;
        }
        return false;
    }
}

var middleware = new TraefikHttpMiddleware
{
    AddPrefix = new() { Prefix = "/v1" },
    BasicAuth = new() { Users = new() { "admin:..." } },
    //                                       ^^^^^^^^^^^^^^^^
    //  TFK001: 'TraefikHttpMiddleware' is a Traefik discriminated
    //  union — exactly one branch must be set, but the initializer
    //  assigns 2
};

// from TraefikBundleGenerator.cs, inside RegisterSourceOutput:
context.RegisterSourceOutput(unifiedSchema, static (ctx, unified) =>
{
    if (unified.Definitions.Count == 0 && unified.RootProperties.Count == 0)
    {
        // TFK004: no schemas were wired in. The consumer's csproj is
        // missing <AdditionalFiles Include="schemas\traefik-v3-*.json" />.
        ctx.ReportDiagnostic(Diagnostic.Create(
            Analyzers.TraefikDiagnostics.NoSchemasFound,
            Location.None));
        return;
    }

    var ns = "FrenchExDev.Net.Traefik.Bundle";
    Emit(ctx, ns, unified);
});