Part 3: Reading JSON Schemas in an Incremental Generator📋

[Generator]
public sealed class TraefikBundleGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // Stage 1: filter the AdditionalTexts to schemas we care about, then
        // parse each one to a SchemaModel inside a Select so Roslyn can cache
        // the parsed result. SchemaModel implements structural equality, so
        // editing whitespace in a .json schema doesn't bust the downstream
        // emit cache when the parsed shape is identical.
        var parsedSchemas = context.AdditionalTextsProvider
            .Where(static f => Path.GetFileName(f.Path).StartsWith("traefik-v") &&
                               f.Path.EndsWith(".json"))
            .Select(static (file, ct) =>
            {
                var text = file.GetText(ct);
                if (text is null) return null;
                var filename = Path.GetFileName(file.Path);
                var kind = TraefikSchemaReader.DetectKind(filename);
                var version = TraefikSchemaReader.ExtractVersion(filename);
                try
                {
                    return TraefikSchemaReader.Parse(text.ToString(), version, kind);
                }
                catch
                {
                    return null;
                }
            });

        // Stage 2: collect + merge into the UnifiedSchema. Also value-equal,
        // so this stage caches too.
        var unifiedSchema = parsedSchemas.Collect().Select(static (schemas, ct) =>
        {
            var ordered = schemas
                .Where(static s => s is not null)
                .OrderBy(static s => s!.Version, StringComparer.Ordinal)
                .ToList();
            // … merge definitions, stamp SinceVersion on properties first
            //   seen in a later schema version (see Part 10).
            return new UnifiedSchema { … };
        });

        // Stage 3: emit. Only re-runs when the UnifiedSchema's structural
        // equality differs from the previously cached one.
        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);
        });
    }
    // … Emit() shown in Part 5
}

internal sealed class SchemaModel : IEquatable<SchemaModel>
{
    public string Version { get; set; } = "";
    public SchemaKind Kind { get; set; }                       // Static or Dynamic
    public Dictionary<string, DefinitionModel> Definitions { get; set; } = new();
    public List<PropertyModel> RootProperties { get; set; } = new();
    // … Equals / GetHashCode use IrEquality helpers — see Part 4
}

internal enum SchemaKind { Static, Dynamic }

internal sealed class DefinitionModel : IEquatable<DefinitionModel>
{
    public string Name { get; set; } = "";
    public string? Description { get; set; }
    public List<PropertyModel> Properties { get; set; } = new();
    public bool IsOneOfDiscriminated { get; set; }
    public List<DiscriminatedBranch>? Branches { get; set; }
}

namespace FrenchExDev.Net.Traefik.Bundle.Attributes;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Assembly)]
public sealed class TraefikBundleAttribute : Attribute { }