DreamineEntryGenerator.cs

이 파일의 문서화 페이지로 가기

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using System.Collections.Immutable;
using System.Linq;
using System.Text;
 
namespace Dreamine.MVVM.Generators
{
    [Generator]
    public sealed class DreamineEntryGenerator : IIncrementalGenerator
    {
        private const string EntryAttributeMetadataName = "Dreamine.MVVM.Attributes.DreamineEntryAttribute";
        private const string WpfApplicationMetadataName = "System.Windows.Application";
 
        private static readonly DiagnosticDescriptor EntryMustBePartialDescriptor = new(
            id: "DMG001",
            title: "Entry class must be partial",
            messageFormat: "Class '{0}' marked with [DreamineEntry] must be declared partial",
            category: "Dreamine.MVVM.Generators",
            defaultSeverity: DiagnosticSeverity.Error,
            isEnabledByDefault: true);
 
        private static readonly DiagnosticDescriptor EntryMustInheritApplicationDescriptor = new(
            id: "DMG002",
            title: "Entry class must inherit Application",
            messageFormat: "Class '{0}' marked with [DreamineEntry] must inherit System.Windows.Application",
            category: "Dreamine.MVVM.Generators",
            defaultSeverity: DiagnosticSeverity.Error,
            isEnabledByDefault: true);
 
        private static readonly DiagnosticDescriptor DuplicateEntryDescriptor = new(
            id: "DMG003",
            title: "Only one entry class is allowed",
            messageFormat: "Only one valid [DreamineEntry] class is allowed but '{0}' is also marked as an entry",
            category: "Dreamine.MVVM.Generators",
            defaultSeverity: DiagnosticSeverity.Error,
            isEnabledByDefault: true);

        public void Initialize(IncrementalGeneratorInitializationContext context)
        {
            IncrementalValueProvider<INamedTypeSymbol?> entryAttributeSymbolProvider =
                context.CompilationProvider.Select(
                    static (compilation, _) => compilation.GetTypeByMetadataName(EntryAttributeMetadataName));
 
            IncrementalValueProvider<INamedTypeSymbol?> applicationSymbolProvider =
                context.CompilationProvider.Select(
                    static (compilation, _) => compilation.GetTypeByMetadataName(WpfApplicationMetadataName));
 
            IncrementalValueProvider<(INamedTypeSymbol? EntryAttributeSymbol, INamedTypeSymbol? ApplicationSymbol)> symbolsProvider =
                entryAttributeSymbolProvider.Combine(applicationSymbolProvider);
 
            IncrementalValueProvider<ImmutableArray<EntryCandidateModel>> candidateProvider =
                context.SyntaxProvider
                    .CreateSyntaxProvider(
                        predicate: static (node, _) => IsCandidateSyntax(node),
                        transform: static (syntaxContext, _) => syntaxContext)
                    .Combine(symbolsProvider)
                    .Select(static (pair, _) => TryCreateCandidate(pair.Left, pair.Right.EntryAttributeSymbol, pair.Right.ApplicationSymbol))
                    .Where(static candidate => candidate is not null)
                    .Select(static (candidate, _) => candidate!)
                    .Collect();
 
            context.RegisterSourceOutput(candidateProvider, static (sourceProductionContext, candidates) =>
            {
                Emit(sourceProductionContext, candidates);
            });
        }

        private static bool IsCandidateSyntax(SyntaxNode node)
        {
            return node is ClassDeclarationSyntax classDeclaration &&
                   classDeclaration.AttributeLists.Count > 0;
        }

        private static EntryCandidateModel? TryCreateCandidate(
            GeneratorSyntaxContext context,
            INamedTypeSymbol? entryAttributeSymbol,
            INamedTypeSymbol? applicationSymbol)
        {
            if (entryAttributeSymbol is null || applicationSymbol is null)
            {
                return null;
            }
 
            if (context.Node is not ClassDeclarationSyntax classDeclaration)
            {
                return null;
            }
 
            if (context.SemanticModel.GetDeclaredSymbol(classDeclaration) is not INamedTypeSymbol classSymbol)
            {
                return null;
            }
 
            bool hasEntryAttribute = classSymbol
                .GetAttributes()
                .Any(attribute => SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, entryAttributeSymbol));
 
            if (!hasEntryAttribute)
            {
                return null;
            }
 
            string namespaceName = classSymbol.ContainingNamespace is { IsGlobalNamespace: false }
                ? classSymbol.ContainingNamespace.ToDisplayString()
                : string.Empty;
 
            return new EntryCandidateModel(
                classSymbol,
                classDeclaration,
                namespaceName,
                classSymbol.Name,
                IsPartial(classDeclaration),
                InheritsFrom(classSymbol, applicationSymbol));
        }

        private static void Emit(
            SourceProductionContext context,
            ImmutableArray<EntryCandidateModel> candidates)
        {
            if (candidates.IsDefaultOrEmpty)
            {
                return;
            }
 
            foreach (EntryCandidateModel candidate in candidates)
            {
                if (!candidate.IsPartial)
                {
                    context.ReportDiagnostic(Diagnostic.Create(
                        EntryMustBePartialDescriptor,
                        candidate.ClassDeclaration.Identifier.GetLocation(),
                        candidate.ClassName));
                }
 
                if (!candidate.IsApplicationDerived)
                {
                    context.ReportDiagnostic(Diagnostic.Create(
                        EntryMustInheritApplicationDescriptor,
                        candidate.ClassDeclaration.Identifier.GetLocation(),
                        candidate.ClassName));
                }
            }
 
            ImmutableArray<EntryCandidateModel> validCandidates = candidates
                .Where(static candidate => candidate.IsPartial && candidate.IsApplicationDerived)
                .ToImmutableArray();
 
            if (validCandidates.Length == 0)
            {
                return;
            }
 
            if (validCandidates.Length > 1)
            {
                foreach (EntryCandidateModel candidate in validCandidates)
                {
                    context.ReportDiagnostic(Diagnostic.Create(
                        DuplicateEntryDescriptor,
                        candidate.ClassDeclaration.Identifier.GetLocation(),
                        candidate.ClassName));
                }
 
                return;
            }
 
            EntryCandidateModel entryCandidate = validCandidates[0];
            string source = BuildEntrySource(entryCandidate.Namespace, entryCandidate.ClassName);
 
            context.AddSource(
                $"{entryCandidate.ClassName}.DreamineEntry.g.cs",
                SourceText.From(source, Encoding.UTF8));
        }

        private static bool IsPartial(ClassDeclarationSyntax classDeclaration)
        {
            return classDeclaration.Modifiers.Any(static modifier => modifier.IsKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind.PartialKeyword));
        }

        private static bool InheritsFrom(INamedTypeSymbol symbol, INamedTypeSymbol baseTypeSymbol)
        {
            INamedTypeSymbol? current = symbol;
 
            while (current is not null)
            {
                if (SymbolEqualityComparer.Default.Equals(current, baseTypeSymbol))
                {
                    return true;
                }
 
                current = current.BaseType;
            }
 
            return false;
        }

        private static string BuildEntrySource(string namespaceName, string className)
        {
            string namespaceBlockStart = string.IsNullOrWhiteSpace(namespaceName)
                ? string.Empty
                : $"namespace {namespaceName}\r\n{{";
 
            string namespaceBlockEnd = string.IsNullOrWhiteSpace(namespaceName)
                ? string.Empty
                : "}";
 
            return $$"""
// <auto-generated />
#nullable enable
using System.Windows;
using Dreamine.MVVM.Wpf;
 
{{namespaceBlockStart}}
    public partial class {{className}}
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);
 
            var rootAssembly = typeof({{className}}).Assembly;
 
            RegisterBefore();
 
            DreamineWpfOptions options = DreamineWpfOptions.CreateDefault();
            ConfigureDreamine(options);
 
            DreamineAppBuilder.Initialize(rootAssembly, options);
 
            ShowMainWindow();
            Dispatcher.InvokeAsync(() => RegisterAfter());
        }

        static partial void RegisterBefore();

        static partial void ConfigureDreamine(DreamineWpfOptions options);

        static partial void RegisterAfter();

        static partial void ShowMainWindow();
    }
{{namespaceBlockEnd}}
""";
        }
    }
}