DreamineAutoWiringGenerator.cs

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

using Microsoft.CodeAnalysis;
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 DreamineAutoWiringGenerator : IIncrementalGenerator
    {
        private const string ModelAttributeMetadataName = "Dreamine.MVVM.Attributes.DreamineModelAttribute";
        private const string EventAttributeMetadataName = "Dreamine.MVVM.Attributes.DreamineEventAttribute";
        private const string PropertyAttributeMetadataName = "Dreamine.MVVM.Attributes.DreaminePropertyAttribute";

        public void Initialize(IncrementalGeneratorInitializationContext context)
        {
            IncrementalValueProvider<AttributeSymbolSet> attributeSymbolsProvider =
                context.CompilationProvider.Select(
                    static (compilation, _) => new AttributeSymbolSet(
                        compilation.GetTypeByMetadataName(ModelAttributeMetadataName),
                        compilation.GetTypeByMetadataName(EventAttributeMetadataName),
                        compilation.GetTypeByMetadataName(PropertyAttributeMetadataName)));
 
            IncrementalValueProvider<ImmutableArray<AutoWiringCandidate>> candidatesProvider =
                context.SyntaxProvider
                    .CreateSyntaxProvider(
                        predicate: static (node, _) => IsCandidateSyntax(node),
                        transform: static (syntaxContext, _) => syntaxContext)
                    .Combine(attributeSymbolsProvider)
                    .Select(static (pair, _) => TryCreateCandidate(pair.Left, pair.Right))
                    .Where(static candidate => candidate is not null)
                    .Select(static (candidate, _) => candidate!)
                    .Collect();
 
            context.RegisterSourceOutput(candidatesProvider, static (sourceProductionContext, candidates) =>
            {
                Emit(sourceProductionContext, candidates);
            });
        }

        private static bool IsCandidateSyntax(SyntaxNode node)
        {
            if (node is not VariableDeclaratorSyntax variable)
            {
                return false;
            }
 
            if (variable.Parent is not VariableDeclarationSyntax variableDeclaration)
            {
                return false;
            }
 
            if (variableDeclaration.Parent is not FieldDeclarationSyntax fieldDeclaration)
            {
                return false;
            }
 
            return fieldDeclaration.AttributeLists.Count > 0;
        }

        private static AutoWiringCandidate? TryCreateCandidate(
            GeneratorSyntaxContext context,
            AttributeSymbolSet attributeSymbols)
        {
            if (attributeSymbols.IsIncomplete)
            {
                return null;
            }
 
            if (context.Node is not VariableDeclaratorSyntax variable)
            {
                return null;
            }
 
            if (context.SemanticModel.GetDeclaredSymbol(variable) is not IFieldSymbol fieldSymbol)
            {
                return null;
            }
 
            if (fieldSymbol.ContainingType is null)
            {
                return null;
            }
 
            // 1차 버전에서는 중첩 타입은 제외
            if (fieldSymbol.ContainingType.ContainingType is not null)
            {
                return null;
            }
 
            AttributeData? matchedAttribute;
            CandidateKind? kind = GetCandidateKind(fieldSymbol, attributeSymbols, out matchedAttribute);
            if (kind is null || matchedAttribute is null)
            {
                return null;
            }
 
            string? configuredPropertyName = GetConfiguredPropertyName(matchedAttribute);
            string? generatedPropertyName = ResolveGeneratedPropertyName(fieldSymbol.Name, configuredPropertyName);
 
            if (string.IsNullOrWhiteSpace(generatedPropertyName))
            {
                return null;
            }
 
            return new AutoWiringCandidate(
                fieldSymbol,
                fieldSymbol.ContainingType,
                kind.Value,
                generatedPropertyName!);
        }

        private static void Emit(
            SourceProductionContext context,
            ImmutableArray<AutoWiringCandidate> candidates)
        {
            if (candidates.IsDefaultOrEmpty)
            {
                return;
            }
 
            foreach (AutoWiringCandidate candidate in candidates)
            {
                if (HasConflictingMember(candidate.ContainingType, candidate.GeneratedPropertyName))
                {
                    continue;
                }
 
                string source = BuildSource(candidate);
                string fileName = BuildFileName(candidate);
 
                context.AddSource(fileName, SourceText.From(source, Encoding.UTF8));
            }
        }

        private static CandidateKind? GetCandidateKind(
            IFieldSymbol fieldSymbol,
            AttributeSymbolSet attributeSymbols,
            out AttributeData? matchedAttribute)
        {
            foreach (AttributeData attribute in fieldSymbol.GetAttributes())
            {
                INamedTypeSymbol? attributeClass = attribute.AttributeClass;
                if (attributeClass is null)
                {
                    continue;
                }
 
                if (SymbolEqualityComparer.Default.Equals(attributeClass, attributeSymbols.ModelAttribute))
                {
                    matchedAttribute = attribute;
                    return CandidateKind.Model;
                }
 
                if (SymbolEqualityComparer.Default.Equals(attributeClass, attributeSymbols.EventAttribute))
                {
                    matchedAttribute = attribute;
                    return CandidateKind.Event;
                }
 
                if (SymbolEqualityComparer.Default.Equals(attributeClass, attributeSymbols.PropertyAttribute))
                {
                    matchedAttribute = attribute;
                    return CandidateKind.Property;
                }
            }
 
            matchedAttribute = null;
            return null;
        }

        private static string? GetConfiguredPropertyName(AttributeData attribute)
        {
            foreach (KeyValuePair<string, TypedConstant> namedArgument in attribute.NamedArguments)
            {
                if (namedArgument.Key == "PropertyName" &&
                    namedArgument.Value.Value is string namedValue &&
                    !string.IsNullOrWhiteSpace(namedValue))
                {
                    return namedValue;
                }
            }
 
            if (attribute.ConstructorArguments.Length > 0 &&
                attribute.ConstructorArguments[0].Value is string ctorValue &&
                !string.IsNullOrWhiteSpace(ctorValue))
            {
                return ctorValue;
            }
 
            return null;
        }

        private static string? ResolveGeneratedPropertyName(string fieldName, string? configuredPropertyName)
        {
            if (!string.IsNullOrWhiteSpace(configuredPropertyName))
            {
                return configuredPropertyName;
            }
 
            string normalized = fieldName.TrimStart('_');
            if (string.IsNullOrWhiteSpace(normalized))
            {
                return null;
            }
 
            if (normalized.Length == 1)
            {
                return normalized.ToUpperInvariant();
            }
 
            return char.ToUpperInvariant(normalized[0]) + normalized.Substring(1);
        }

        private static bool HasConflictingMember(INamedTypeSymbol typeSymbol, string memberName)
        {
            return typeSymbol.GetMembers(memberName).Length > 0;
        }

        private static string BuildFileName(AutoWiringCandidate candidate)
        {
            string namespaceName = candidate.ContainingType.ContainingNamespace.IsGlobalNamespace
                ? "Global"
                : Sanitize(candidate.ContainingType.ContainingNamespace.ToDisplayString());
 
            return namespaceName + "_" +
                   candidate.ContainingType.Name + "_" +
                   candidate.GeneratedPropertyName + "_AutoWiring.g.cs";
        }

        private static string BuildSource(AutoWiringCandidate candidate)
        {
            string namespaceName = candidate.ContainingType.ContainingNamespace.IsGlobalNamespace
                ? string.Empty
                : candidate.ContainingType.ContainingNamespace.ToDisplayString();
 
            string className = candidate.ContainingType.Name;
            string typeName = candidate.FieldSymbol.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
            string fieldName = candidate.FieldSymbol.Name;
            string propertyName = candidate.GeneratedPropertyName;
 
            StringBuilder builder = new StringBuilder();
            builder.AppendLine("// <auto-generated />");
            builder.AppendLine("#nullable enable");
            builder.AppendLine("using Dreamine.MVVM.Core;");
 
            if (!string.IsNullOrWhiteSpace(namespaceName))
            {
                builder.AppendLine("namespace " + namespaceName);
                builder.AppendLine("{");
            }
 
            builder.AppendLine("    public partial class " + className);
            builder.AppendLine("    {");
 
            AppendPropertyCode(builder, candidate.Kind, candidate.FieldSymbol, typeName, fieldName, propertyName);
 
            builder.AppendLine("    }");
 
            if (!string.IsNullOrWhiteSpace(namespaceName))
            {
                builder.AppendLine("}");
            }
 
            return builder.ToString();
        }

        private static void AppendPropertyCode(
            StringBuilder builder,
            CandidateKind kind,
            IFieldSymbol fieldSymbol,
            string typeName,
            string fieldName,
            string propertyName)
        {
            switch (kind)
            {
                case CandidateKind.Property:
                    builder.AppendLine("        /// <summary>");
                    builder.AppendLine("        /// 생성된 프로퍼티입니다.");
                    builder.AppendLine("        /// </summary>");
                    builder.AppendLine("        public " + typeName + " " + propertyName);
                    builder.AppendLine("        {");
                    builder.AppendLine("            get => " + fieldName + ";");
                    builder.AppendLine("            set => SetProperty(ref " + fieldName + ", value);");
                    builder.AppendLine("        }");
                    break;
 
                case CandidateKind.Model:
                    AppendLazyAccessPropertyCode(
                        builder,
                        fieldSymbol,
                        typeName,
                        fieldName,
                        propertyName,
                        "new " + typeName + "()");
                    break;
 
                case CandidateKind.Event:
                    AppendLazyAccessPropertyCode(
                        builder,
                        fieldSymbol,
                        typeName,
                        fieldName,
                        propertyName,
                        "DMContainer.Resolve<" + typeName + ">()");
                    break;
            }
        }

        private static void AppendLazyAccessPropertyCode(
            StringBuilder builder,
            IFieldSymbol fieldSymbol,
            string typeName,
            string fieldName,
            string propertyName,
            string initializerExpression)
        {
            builder.AppendLine("        /// <summary>");
            builder.AppendLine("        /// 생성된 참조 프로퍼티입니다.");
            builder.AppendLine("        /// </summary>");
 
            if (fieldSymbol.IsReadOnly || fieldSymbol.Type.IsValueType)
            {
                builder.AppendLine("        public " + typeName + " " + propertyName + " => " + fieldName + ";");
                return;
            }
 
            builder.AppendLine("        public " + typeName + " " + propertyName);
            builder.AppendLine("        {");
            builder.AppendLine("            get");
            builder.AppendLine("            {");
            builder.AppendLine("                if (" + fieldName + " is null)");
            builder.AppendLine("                {");
            builder.AppendLine("                    " + fieldName + " = " + initializerExpression + ";");
            builder.AppendLine("                }");
            builder.AppendLine();
            builder.AppendLine("                return " + fieldName + ";");
            builder.AppendLine("            }");
            builder.AppendLine("        }");
        }

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

        private enum CandidateKind
        {
            Model,
            Event,
            Property
        }

        private sealed class AttributeSymbolSet
        {
            public AttributeSymbolSet(
                INamedTypeSymbol? modelAttribute,
                INamedTypeSymbol? eventAttribute,
                INamedTypeSymbol? propertyAttribute)
            {
                ModelAttribute = modelAttribute;
                EventAttribute = eventAttribute;
                PropertyAttribute = propertyAttribute;
            }

            public INamedTypeSymbol? ModelAttribute { get; }

            public INamedTypeSymbol? EventAttribute { get; }

            public INamedTypeSymbol? PropertyAttribute { get; }

            public bool IsIncomplete
            {
                get
                {
                    return ModelAttribute is null ||
                           EventAttribute is null ||
                           PropertyAttribute is null;
                }
            }
        }

        private sealed class AutoWiringCandidate
        {
            public AutoWiringCandidate(
                IFieldSymbol fieldSymbol,
                INamedTypeSymbol containingType,
                CandidateKind kind,
                string generatedPropertyName)
            {
                FieldSymbol = fieldSymbol;
                ContainingType = containingType;
                Kind = kind;
                GeneratedPropertyName = generatedPropertyName;
            }

            public IFieldSymbol FieldSymbol { get; }

            public INamedTypeSymbol ContainingType { get; }

            public CandidateKind Kind { get; }

            public string GeneratedPropertyName { get; }
        }
    }
}