DreamineCommandSourceGenerator.cs

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

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Text;
 
namespace Dreamine.MVVM.Generators
{
    [Generator]
    public sealed class DreamineCommandSourceGenerator : IIncrementalGenerator
    {
        private const string DreamineCommandAttributeMetadataName = "Dreamine.MVVM.Attributes.DreamineCommandAttribute";
 
        private static readonly DiagnosticDescriptor MethodMustBePartialDescriptor = new(
            id: "DMCMD001",
            title: "DreamineCommand method must be partial",
            messageFormat: "Method '{0}' marked with forwarding [DreamineCommand] must be declared partial",
            category: "Dreamine.MVVM.Generators",
            defaultSeverity: DiagnosticSeverity.Error,
            isEnabledByDefault: true);
 
        private static readonly DiagnosticDescriptor ContainingTypeMustBePartialDescriptor = new(
            id: "DMCMD002",
            title: "Containing type must be partial",
            messageFormat: "Containing type '{0}' for [DreamineCommand] method must be declared partial",
            category: "Dreamine.MVVM.Generators",
            defaultSeverity: DiagnosticSeverity.Error,
            isEnabledByDefault: true);
 
        private static readonly DiagnosticDescriptor MethodMustBeParameterlessVoidDescriptor = new(
            id: "DMCMD003",
            title: "DreamineCommand method must be parameterless void",
            messageFormat: "Method '{0}' marked with [DreamineCommand] must be a parameterless void method",
            category: "Dreamine.MVVM.Generators",
            defaultSeverity: DiagnosticSeverity.Error,
            isEnabledByDefault: true);
 
        private static readonly DiagnosticDescriptor CommandNameConflictDescriptor = new(
            id: "DMCMD004",
            title: "Generated command property name conflicts with an existing member",
            messageFormat: "Generated command property '{0}' conflicts with an existing member in type '{1}'",
            category: "Dreamine.MVVM.Generators",
            defaultSeverity: DiagnosticSeverity.Error,
            isEnabledByDefault: true);
 
        private static readonly DiagnosticDescriptor CanExecuteMethodNotFoundDescriptor = new(
            id: "DMCMD005",
            title: "CanExecute method not found",
            messageFormat: "CanExecute method '{0}' specified on [DreamineCommand] was not found in type '{1}'. The method must be a parameterless bool method.",
            category: "Dreamine.MVVM.Generators",
            defaultSeverity: DiagnosticSeverity.Warning,
            isEnabledByDefault: true);

        public void Initialize(IncrementalGeneratorInitializationContext context)
        {
            IncrementalValueProvider<INamedTypeSymbol?> attributeSymbolProvider =
                context.CompilationProvider.Select(
                    static (compilation, _) => compilation.GetTypeByMetadataName(DreamineCommandAttributeMetadataName));
 
            IncrementalValueProvider<ImmutableArray<CommandCandidateModel>> candidateProvider =
                context.SyntaxProvider
                    .CreateSyntaxProvider(
                        predicate: static (node, _) => node is MethodDeclarationSyntax { AttributeLists.Count: > 0 },
                        transform: static (syntaxContext, _) => syntaxContext)
                    .Combine(attributeSymbolProvider)
                    .Select(static (pair, _) => TryCreateCandidate(pair.Left, pair.Right))
                    .Where(static candidate => candidate is not null)
                    .Select(static (candidate, _) => candidate!)
                    .Collect();
 
            context.RegisterSourceOutput(candidateProvider, static (sourceProductionContext, candidates) =>
            {
                Emit(sourceProductionContext, candidates);
            });
        }

        private static CommandCandidateModel? TryCreateCandidate(
            GeneratorSyntaxContext context,
            INamedTypeSymbol? attributeSymbol)
        {
            if (attributeSymbol is null)
            {
                return null;
            }
 
            if (context.Node is not MethodDeclarationSyntax methodSyntax)
            {
                return null;
            }
 
            if (context.SemanticModel.GetDeclaredSymbol(methodSyntax) is not IMethodSymbol methodSymbol)
            {
                return null;
            }
 
            AttributeData? attributeData = methodSymbol
                .GetAttributes()
                .FirstOrDefault(attribute => SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, attributeSymbol));
 
            if (attributeData is null)
            {
                return null;
            }
 
            string? targetMethod = GetConstructorStringArgument(attributeData, 0);
            string? bindTo = GetNamedStringArgument(attributeData, "BindTo");
            string? commandNameOverride = GetNamedStringArgument(attributeData, "CommandName");
            string? canExecuteMethod = GetNamedStringArgument(attributeData, "CanExecute");
 
            string commandPropertyName = BuildCommandPropertyName(methodSymbol.Name, commandNameOverride);
 
            return new CommandCandidateModel(
                methodSyntax,
                methodSymbol,
                targetMethod,
                bindTo,
                commandPropertyName,
                canExecuteMethod);
        }

        private static void Emit(
            SourceProductionContext context,
            ImmutableArray<CommandCandidateModel> candidates)
        {
            if (candidates.IsDefaultOrEmpty)
            {
                return;
            }
 
            foreach (CommandCandidateModel candidate in candidates)
            {
                List<Diagnostic> diagnostics = ValidateCandidate(candidate);
                foreach (Diagnostic diagnostic in diagnostics)
                {
                    context.ReportDiagnostic(diagnostic);
                }
 
                if (diagnostics.Count > 0)
                {
                    continue;
                }
 
                string source = BuildSource(candidate);
                string fileName = BuildFileName(candidate);
 
                context.AddSource(fileName, SourceText.From(source, Encoding.UTF8));
            }
        }

        private static List<Diagnostic> ValidateCandidate(CommandCandidateModel candidate)
        {
            List<Diagnostic> diagnostics = new List<Diagnostic>();
 
            bool hasTargetMethod = !string.IsNullOrWhiteSpace(candidate.TargetMethod);
 
            if (hasTargetMethod && !IsPartialMethod(candidate.MethodSyntax))
            {
                diagnostics.Add(Diagnostic.Create(
                    MethodMustBePartialDescriptor,
                    candidate.MethodSyntax.Identifier.GetLocation(),
                    candidate.MethodSymbol.ToDisplayString()));
            }
 
            if (!IsContainingTypePartial(candidate.MethodSymbol.ContainingType))
            {
                diagnostics.Add(Diagnostic.Create(
                    ContainingTypeMustBePartialDescriptor,
                    candidate.MethodSyntax.Identifier.GetLocation(),
                    candidate.MethodSymbol.ContainingType.ToDisplayString()));
            }
 
            if (!IsParameterlessVoidMethod(candidate.MethodSymbol))
            {
                diagnostics.Add(Diagnostic.Create(
                    MethodMustBeParameterlessVoidDescriptor,
                    candidate.MethodSyntax.Identifier.GetLocation(),
                    candidate.MethodSymbol.ToDisplayString()));
            }
 
            if (HasConflictingMember(candidate.MethodSymbol.ContainingType, candidate.CommandPropertyName))
            {
                diagnostics.Add(Diagnostic.Create(
                    CommandNameConflictDescriptor,
                    candidate.MethodSyntax.Identifier.GetLocation(),
                    candidate.CommandPropertyName,
                    candidate.MethodSymbol.ContainingType.ToDisplayString()));
            }
 
            if (!string.IsNullOrWhiteSpace(candidate.CanExecuteMethod) &&
                !HasValidCanExecuteMethod(candidate.MethodSymbol.ContainingType, candidate.CanExecuteMethod!))
            {
                diagnostics.Add(Diagnostic.Create(
                    CanExecuteMethodNotFoundDescriptor,
                    candidate.MethodSyntax.Identifier.GetLocation(),
                    candidate.CanExecuteMethod,
                    candidate.MethodSymbol.ContainingType.ToDisplayString()));
            }
 
            return diagnostics;
        }

        private static bool IsPartialMethod(MethodDeclarationSyntax methodSyntax)
        {
            return methodSyntax.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PartialKeyword));
        }

        private static bool IsContainingTypePartial(INamedTypeSymbol typeSymbol)
        {
            foreach (SyntaxReference syntaxReference in typeSymbol.DeclaringSyntaxReferences)
            {
                if (syntaxReference.GetSyntax() is TypeDeclarationSyntax typeDeclaration &&
                    typeDeclaration.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PartialKeyword)))
                {
                    return true;
                }
            }
 
            return false;
        }

        private static bool IsParameterlessVoidMethod(IMethodSymbol methodSymbol)
        {
            return methodSymbol.Parameters.Length == 0 &&
                   methodSymbol.ReturnsVoid &&
                   !methodSymbol.IsGenericMethod;
        }

        private static bool HasConflictingMember(INamedTypeSymbol typeSymbol, string memberName)
        {
            return typeSymbol.GetMembers(memberName).Any();
        }
 
        private static bool HasValidCanExecuteMethod(INamedTypeSymbol typeSymbol, string methodName)
        {
            return typeSymbol.GetMembers(methodName)
                .OfType<IMethodSymbol>()
                .Any(m => m.Parameters.Length == 0 &&
                          !m.ReturnsVoid &&
                          m.ReturnType.SpecialType == SpecialType.System_Boolean);
        }

        private static string BuildCommandPropertyName(string methodName, string? commandNameOverride)
        {
            if (!string.IsNullOrWhiteSpace(commandNameOverride))
            {
                return commandNameOverride!;
            }
 
            return methodName + "Command";
        }

        private static string BuildFileName(CommandCandidateModel candidate)
        {
            string namespaceName = candidate.MethodSymbol.ContainingNamespace.IsGlobalNamespace
                ? "Global"
                : Sanitize(candidate.MethodSymbol.ContainingNamespace.ToDisplayString());
 
            string typeName = string.Join("_", GetContainingTypeChain(candidate.MethodSymbol.ContainingType).Select(type => type.Name));
            string methodName = candidate.MethodSymbol.Name;
 
            return namespaceName + "_" + typeName + "_" + methodName + "_DreamineCommand.g.cs";
        }

        private static string BuildSource(CommandCandidateModel candidate)
        {
            string namespaceName = candidate.MethodSymbol.ContainingNamespace.IsGlobalNamespace
                ? string.Empty
                : candidate.MethodSymbol.ContainingNamespace.ToDisplayString();
 
            List<INamedTypeSymbol> typeChain = GetContainingTypeChain(candidate.MethodSymbol.ContainingType);
            string commandFieldName = "_" + ToCamel(candidate.CommandPropertyName);
            string helperTypeName = "__DreamineGeneratedCommand_" + candidate.MethodSymbol.Name;
            bool hasTargetMethod = !string.IsNullOrWhiteSpace(candidate.TargetMethod);
            string? normalizedInvocation = hasTargetMethod
                ? NormalizeInvocation(candidate.TargetMethod!)
                : null;
 
            StringBuilder builder = new StringBuilder();
            builder.AppendLine("// <auto-generated />");
            builder.AppendLine("#nullable enable");
            builder.AppendLine("using System;");
            builder.AppendLine("using System.Windows.Input;");
            builder.AppendLine();
 
            if (!string.IsNullOrWhiteSpace(namespaceName))
            {
                builder.AppendLine("namespace " + namespaceName);
                builder.AppendLine("{");
            }
 
            for (int i = 0; i < typeChain.Count; i++)
            {
                string indent = new string(' ', 4 * (i + 1));
                builder.AppendLine(indent + GetTypeDeclarationHeader(typeChain[i]));
                builder.AppendLine(indent + "{");
            }
 
            string memberIndent = new string(' ', 4 * (typeChain.Count + 1));
 
            builder.AppendLine(memberIndent + "/// <summary>");
            builder.AppendLine(memberIndent + "/// 생성된 ICommand 프로퍼티입니다.");
            builder.AppendLine(memberIndent + "/// </summary>");
            builder.AppendLine(memberIndent + "private ICommand? " + commandFieldName + ";");
            string ctorArgs = !string.IsNullOrWhiteSpace(candidate.CanExecuteMethod)
                ? candidate.MethodSymbol.Name + ", " + candidate.CanExecuteMethod
                : candidate.MethodSymbol.Name;
            builder.AppendLine(memberIndent + "public ICommand " + candidate.CommandPropertyName + " => " + commandFieldName + " ??= new " + helperTypeName + "(" + ctorArgs + ");");
            builder.AppendLine();
 
            bool hasBody = candidate.MethodSyntax.Body is not null || candidate.MethodSyntax.ExpressionBody is not null;
            if (hasTargetMethod && !hasBody)
            {
                builder.AppendLine(memberIndent + GetMethodSignatureWithoutAttributes(candidate.MethodSyntax));
                builder.AppendLine(memberIndent + "{");
 
                if (!string.IsNullOrWhiteSpace(candidate.BindTo))
                {
                    builder.AppendLine(memberIndent + "    var __result = " + normalizedInvocation + ";");
                    builder.AppendLine(memberIndent + "    " + candidate.BindTo + " = __result;");
                }
                else
                {
                    builder.AppendLine(memberIndent + "    " + normalizedInvocation + ";");
                }
 
                builder.AppendLine(memberIndent + "}");
                builder.AppendLine();
            }
 
            bool hasCanExecute = !string.IsNullOrWhiteSpace(candidate.CanExecuteMethod);
 
            builder.AppendLine(memberIndent + "private sealed class " + helperTypeName + " : ICommand");
            builder.AppendLine(memberIndent + "{");
            builder.AppendLine(memberIndent + "    private readonly Action _execute;");
            if (hasCanExecute)
            {
                builder.AppendLine(memberIndent + "    private readonly Func<bool> _canExecute;");
                builder.AppendLine(memberIndent + "    public " + helperTypeName + "(Action execute, Func<bool> canExecute)");
                builder.AppendLine(memberIndent + "    {");
                builder.AppendLine(memberIndent + "        _execute = execute ?? throw new ArgumentNullException(nameof(execute));");
                builder.AppendLine(memberIndent + "        _canExecute = canExecute ?? throw new ArgumentNullException(nameof(canExecute));");
                builder.AppendLine(memberIndent + "    }");
            }
            else
            {
                builder.AppendLine(memberIndent + "    public " + helperTypeName + "(Action execute)");
                builder.AppendLine(memberIndent + "    {");
                builder.AppendLine(memberIndent + "        _execute = execute ?? throw new ArgumentNullException(nameof(execute));");
                builder.AppendLine(memberIndent + "    }");
            }
 
            builder.AppendLine(memberIndent + "    public event EventHandler? CanExecuteChanged;");
            builder.AppendLine(memberIndent + "    public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);");
            if (hasCanExecute)
            {
                builder.AppendLine(memberIndent + "    public bool CanExecute(object? parameter) => _canExecute();");
            }
            else
            {
                builder.AppendLine(memberIndent + "    public bool CanExecute(object? parameter) => true;");
            }
 
            builder.AppendLine(memberIndent + "    public void Execute(object? parameter) => _execute();");
            builder.AppendLine(memberIndent + "}");
            builder.AppendLine();
 
            for (int i = typeChain.Count - 1; i >= 0; i--)
            {
                string indent = new string(' ', 4 * (i + 1));
                builder.AppendLine(indent + "}");
            }
 
            if (!string.IsNullOrWhiteSpace(namespaceName))
            {
                builder.AppendLine("}");
            }
 
            return builder.ToString();
        }

        private static string GetMethodSignatureWithoutAttributes(MethodDeclarationSyntax methodSyntax)
        {
            MethodDeclarationSyntax withoutBody = methodSyntax
                .WithAttributeLists(default)
                .WithBody(null)
                .WithExpressionBody(null)
                .WithSemicolonToken(default);
 
            return withoutBody.NormalizeWhitespace().ToFullString();
        }

        private static string? GetConstructorStringArgument(AttributeData attribute, int index)
        {
            if (attribute.ConstructorArguments.Length <= index)
            {
                return null;
            }
 
            return attribute.ConstructorArguments[index].Value?.ToString();
        }

        private static string? GetNamedStringArgument(AttributeData attribute, string name)
        {
            return attribute.NamedArguments
                .Where(argument => string.Equals(argument.Key, name, StringComparison.Ordinal))
                .Select(argument => argument.Value.Value?.ToString())
                .FirstOrDefault();
        }

        private static string NormalizeInvocation(string targetMethod)
        {
            string trimmed = targetMethod.Trim();
 
            if (trimmed.EndsWith(")", StringComparison.Ordinal))
            {
                return trimmed;
            }
 
            return trimmed + "()";
        }

        private static List<INamedTypeSymbol> GetContainingTypeChain(INamedTypeSymbol innerMostType)
        {
            Stack<INamedTypeSymbol> stack = new Stack<INamedTypeSymbol>();
            INamedTypeSymbol? current = innerMostType;
 
            while (current is not null)
            {
                stack.Push(current);
                current = current.ContainingType;
            }
 
            return stack.ToList();
        }

        private static string GetTypeDeclarationHeader(INamedTypeSymbol typeSymbol)
        {
            string kind = typeSymbol.TypeKind switch
            {
                TypeKind.Class => "partial class",
                TypeKind.Struct => "partial struct",
                _ => "partial class"
            };
 
            string accessibility = typeSymbol.DeclaredAccessibility switch
            {
                Accessibility.Public => "public",
                Accessibility.Internal => "internal",
                Accessibility.Private => "private",
                Accessibility.Protected => "protected",
                Accessibility.ProtectedAndInternal => "protected internal",
                Accessibility.ProtectedOrInternal => "protected internal",
                _ => "internal"
            };
 
            string staticKeyword = typeSymbol.IsStatic ? " static" : string.Empty;
 
            string typeParameters = typeSymbol.TypeParameters.Length > 0
                ? "<" + string.Join(", ", typeSymbol.TypeParameters.Select(parameter => parameter.Name)) + ">"
                : string.Empty;
 
            return accessibility + staticKeyword + " " + kind + " " + typeSymbol.Name + typeParameters;
        }

        private static string Sanitize(string name)
        {
            return name.Replace('.', '_').Replace('+', '_');
        }

        private static string ToCamel(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                return name;
            }
 
            if (name.Length == 1)
            {
                return name.ToLowerInvariant();
            }
 
            return char.ToLowerInvariant(name[0]) + name.Substring(1);
        }

        private sealed class CommandCandidateModel
        {
            public CommandCandidateModel(
                MethodDeclarationSyntax methodSyntax,
                IMethodSymbol methodSymbol,
                string? targetMethod,
                string? bindTo,
                string commandPropertyName,
                string? canExecuteMethod = null)
            {
                MethodSyntax = methodSyntax;
                MethodSymbol = methodSymbol;
                TargetMethod = targetMethod;
                BindTo = bindTo;
                CommandPropertyName = commandPropertyName;
                CanExecuteMethod = canExecuteMethod;
            }

            public MethodDeclarationSyntax MethodSyntax { get; }

            public IMethodSymbol MethodSymbol { get; }

            public string? TargetMethod { get; }

            public string? BindTo { get; }

            public string CommandPropertyName { get; }

            public string? CanExecuteMethod { get; }
        }
    }
}