PropertyValuesProviderGenerator using SyntaxFactory

Author: Lightczx

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Extension/AttributeDataExtension.cs

@@ -23,6 +23,7 @@ public static bool HasNamedArgument<T>(this AttributeData attributeData, string
         return false;
     }
 
+    [Obsolete]
     public static bool HasNamedArgument<TValue>(this AttributeData attributeData, string name, Func<TValue, bool> predicate)
     {
         foreach ((string propertyName, TypedConstant constant) in attributeData.NamedArguments)

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Extension/GeneratorSyntaxContextExtension.cs

@@ -2,13 +2,15 @@
 // Licensed under the MIT license.
 
 using Microsoft.CodeAnalysis;
+using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 
 namespace Snap.Hutao.SourceGeneration.Extension;
 
 internal static class GeneratorSyntaxContextExtension
 {
+    [Obsolete]
     public static bool TryGetDeclaredSymbol<TSymbol>(this GeneratorSyntaxContext context, CancellationToken token, [NotNullWhen(true)] out TSymbol? symbol)
         where TSymbol : class, ISymbol
     {

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Primitive/SyntaxExtension.cs renamed to src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Extension/SyntaxExtension.cs

@@ -4,7 +4,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using System;
 
-namespace Snap.Hutao.SourceGeneration.Primitive;
+namespace Snap.Hutao.SourceGeneration.Extension;
 
 internal static class SyntaxExtension
 {

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Model/AttributeInfo.cs

@@ -62,4 +62,17 @@ public AttributeSyntax GetSyntax()
 
         return Attribute(IdentifierName(FullyQualifiedTypeName), AttributeArgumentList(SeparatedList([.. arguments, .. namedArguments])));
     }
+
+    public bool HasNamedArgument(string name, bool value)
+    {
+        foreach ((string propertyName, TypedConstantInfo constant) in NamedArgumentInfo)
+        {
+            if (propertyName == name)
+            {
+                return constant is TypedConstantInfo.Primitive.Boolean argument && argument.Value == value;
+            }
+        }
+
+        return false;
+    }
 }

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Model/HierarchyInfo.cs

@@ -82,10 +82,10 @@ public CompilationUnitSyntax GetCompilationUnit(ImmutableArray<MemberDeclaration
             //
             // <SYNTAX_TRIVIA>
             // <TYPE_HIERARCHY>
-            return
-                CompilationUnit()
-                .AddMembers(typeDeclarationSyntax.WithLeadingTrivia(NullableEnableTriviaList))
-                .NormalizeWhitespace();
+            return CompilationUnit()
+                .WithMembers(SingletonList<MemberDeclarationSyntax>(
+                    typeDeclarationSyntax
+                        .WithLeadingTrivia(NullableEnableTriviaList)));
         }
 
         // Create the compilation unit with disabled warnings, target namespace and generated type.
@@ -94,8 +94,8 @@ public CompilationUnitSyntax GetCompilationUnit(ImmutableArray<MemberDeclaration
         // namespace <NAMESPACE>;
         // <TYPE_HIERARCHY>
         return CompilationUnit()
-            .AddMembers(FileScopedNamespaceDeclaration(Namespace)
-                .AddMembers(typeDeclarationSyntax))
-            .NormalizeWhitespace();
+            .WithMembers(SingletonList<MemberDeclarationSyntax>(FileScopedNamespaceDeclaration(Namespace)
+                .WithMembers(SingletonList<MemberDeclarationSyntax>(typeDeclarationSyntax
+                    .WithLeadingTrivia(NullableEnableTriviaList)))));
     }
 }

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Model/PropertyInfo.cs

@@ -1,17 +1,25 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Microsoft.CodeAnalysis;
+using Snap.Hutao.SourceGeneration.Extension;
+
 namespace Snap.Hutao.SourceGeneration.Model;
 
 internal sealed record PropertyInfo
 {
-    public PropertyInfo(string minimallyQualifiedName, TypeInfo typeInfo)
+    public PropertyInfo(string minimallyQualifiedName, string fullyQualifiedTypeName)
     {
         MinimallyQualifiedName = minimallyQualifiedName;
-        TypeInfo = typeInfo;
+        FullyQualifiedTypeName = fullyQualifiedTypeName;
     }
 
     public string MinimallyQualifiedName { get; }
 
-    public TypeInfo TypeInfo { get; }
+    public string FullyQualifiedTypeName { get; }
+
+    public static PropertyInfo Create(IPropertySymbol propertySymbol)
+    {
+        return new(propertySymbol.Name, propertySymbol.Type.GetFullyQualifiedNameWithNullabilityAnnotations());
+    }
 }

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Model/TypeInfo.cs

@@ -15,13 +15,16 @@ internal sealed record TypeInfo
     public TypeInfo(INamedTypeSymbol symbol)
     {
         FullyQualifiedName = symbol.GetFullyQualifiedName();
+        FullyQualifiedMetadataName = symbol.GetFullyQualifiedMetadataName();
         MinimallyQualifiedName = symbol.GetMinimallyQualifiedName();
         Kind = symbol.TypeKind;
         IsRecord = symbol.IsRecord;
     }
 
     public string FullyQualifiedName { get; }
 
+    public string FullyQualifiedMetadataName { get; }
+
     public string MinimallyQualifiedName { get; }
 
     public TypeKind Kind { get; }

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Primitive/FastSyntaxFactory.LiteralExpression.cs

@@ -9,6 +9,8 @@ namespace Snap.Hutao.SourceGeneration.Primitive;
 
 internal static partial class FastSyntaxFactory
 {
+    public static LiteralExpressionSyntax DefaultLiteralExpression { get; } = SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);
+
     public static LiteralExpressionSyntax FalseLiteralExpression { get; } = SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression);
 
     public static LiteralExpressionSyntax NullLiteralExpression { get; } = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);

src/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration/Xaml/AdvancedCollectionViewItemGenerator.cs

@@ -0,0 +1,115 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Snap.Hutao.SourceGeneration.Extension;
+using Snap.Hutao.SourceGeneration.Model;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+using static Snap.Hutao.SourceGeneration.Primitive.FastSyntaxFactory;
+
+namespace Snap.Hutao.SourceGeneration.Xaml;
+
+[Generator(LanguageNames.CSharp)]
+internal sealed class PropertyValuesProviderGenerator : IIncrementalGenerator
+{
+    public const string InterfaceMetadataName = "Snap.Hutao.UI.Xaml.Data.IPropertyValuesProvider";
+
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        IncrementalValuesProvider<PropertyValuesProviderGeneratorContext> commands = context.SyntaxProvider
+            .CreateSyntaxProvider(FilterTypeWithBaseList, ProviderType)
+            .Where(static c => c is not null);
+
+        context.RegisterSourceOutput(commands, GenerateWrapper);
+    }
+
+    private static bool FilterTypeWithBaseList(SyntaxNode node, CancellationToken token)
+    {
+        return node is TypeDeclarationSyntax { BaseList: not null };
+    }
+
+    private static PropertyValuesProviderGeneratorContext ProviderType(GeneratorSyntaxContext context, CancellationToken token)
+    {
+        if (context.SemanticModel.GetDeclaredSymbol(context.Node) is INamedTypeSymbol typeSymbol)
+        {
+            if (typeSymbol.Interfaces.Any(static symbol => symbol.HasFullyQualifiedMetadataName(InterfaceMetadataName)))
+            {
+                return PropertyValuesProviderGeneratorContext.Create(typeSymbol);
+            }
+        }
+
+        return default!;
+    }
+
+    private static void GenerateWrapper(SourceProductionContext production, PropertyValuesProviderGeneratorContext context)
+    {
+        try
+        {
+            Generate(production, context);
+        }
+        catch (Exception e)
+        {
+            production.AddSource($"Error-{Guid.NewGuid().ToString()}.g.cs", e.ToString());
+        }
+    }
+
+    private static void Generate(SourceProductionContext production, PropertyValuesProviderGeneratorContext context)
+    {
+        CompilationUnitSyntax syntax = context.Hierarchy.GetCompilationUnit(
+            [
+                MethodDeclaration(NullableObjectType, Identifier("GetPropertyValue"))
+                    .WithModifiers(PublicTokenList)
+                    .WithParameterList(ParameterList(SingletonSeparatedList(
+                        Parameter(StringType, Identifier("propertyName")))))
+                    .WithBody(Block(SingletonList(
+                        ReturnStatement(SwitchExpression(IdentifierName("propertyName"))
+                            .WithArms(SeparatedList(GenerateSwitchExpressionArms(context)))))))
+            ])
+            .NormalizeWhitespace();
+
+        production.AddSource(context.Hierarchy.FileNameHint, syntax.ToFullString());
+    }
+
+    private static IEnumerable<SwitchExpressionArmSyntax> GenerateSwitchExpressionArms(PropertyValuesProviderGeneratorContext context)
+    {
+        foreach (PropertyInfo property in context.Properties)
+        {
+            IdentifierNameSyntax propertyName = IdentifierName(property.MinimallyQualifiedName);
+
+            // nameof(${propertyName}) => ${propertyName}
+            yield return SwitchExpressionArm(
+                ConstantPattern(NameOf(propertyName)),
+                propertyName);
+        }
+
+        // _ => default
+        yield return SwitchExpressionArm(DiscardPattern(), DefaultLiteralExpression);
+    }
+
+    private sealed record PropertyValuesProviderGeneratorContext
+    {
+        public required HierarchyInfo Hierarchy { get; init; }
+
+        public required EquatableArray<PropertyInfo> Properties { get; init; }
+
+        public static PropertyValuesProviderGeneratorContext Create(INamedTypeSymbol typeSymbol)
+        {
+            return new()
+            {
+                Hierarchy = HierarchyInfo.From(typeSymbol),
+                Properties = typeSymbol
+                    .GetMembers()
+                    .OfType<IPropertySymbol>()
+                    .Where(static prop => prop.DeclaredAccessibility is Accessibility.Public)
+                    .Select(PropertyInfo.Create)
+                    .ToImmutableArray(),
+            };
+        }
+    }
+}