Improve code fixer for known enum members

Author: Sergio0694

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.CodeFixers/UseGeneratedDependencyPropertyOnManualPropertyCodeFixer.cs

@@ -114,6 +114,71 @@ private static bool TryGetGeneratedDependencyPropertyAttributeList(
         return true;
     }
 
+    /// <summary>
+    /// Updates an <see cref="AttributeListSyntax"/> for the <c>[GeneratedDependencyProperty]</c> attribute with the right default value.
+    /// </summary>
+    /// <param name="document">The original document being fixed.</param>
+    /// <param name="semanticModel">The <see cref="SemanticModel"/> instance for the current compilation.</param>
+    /// <param name="defaultValueExpression">The expression for the default value of the property, if present</param>
+    /// <returns>The updated attribute syntax.</returns>
+    private static AttributeListSyntax UpdateGeneratedDependencyPropertyAttributeList(
+        Document document,
+        SemanticModel semanticModel,
+        AttributeListSyntax generatedDependencyPropertyAttributeList,
+        string? defaultValueExpression)
+    {
+        // If we do have a default value expression, set it in the attribute.
+        // We extract the generated attribute so we can add the new argument.
+        // It's important to reuse it, as it has the "add usings" annotation.
+        if (defaultValueExpression is not null)
+        {
+            ExpressionSyntax parsedExpression = ParseExpression(defaultValueExpression);
+
+            // Special case values which are simple enum member accesses, like 'global::Windows.UI.Xaml.Visibility.Collapsed'
+            if (parsedExpression is MemberAccessExpressionSyntax { Expression: { } expressionSyntax, Name: IdentifierNameSyntax { Identifier.Text: { } memberName } })
+            {
+                string fullyQualifiedTypeName = expressionSyntax.ToFullString();
+
+                // Ensure we strip the global prefix, if present (it should always be present)
+                if (fullyQualifiedTypeName.StartsWith("global::"))
+                {
+                    fullyQualifiedTypeName = fullyQualifiedTypeName["global::".Length..];
+                }
+
+                // Try to resolve the attribute type, if present. This API takes a fully qualified metadata name, not
+                // a fully qualified type name. However, for virtually all cases for enum types, the two should match.
+                // That is, they will be the same if the type is not nested, and not generic, which is what we expect.
+                if (semanticModel.Compilation.GetTypeByMetadataName(fullyQualifiedTypeName) is INamedTypeSymbol enumTypeSymbol)
+                {
+                    SyntaxGenerator syntaxGenerator = SyntaxGenerator.GetGenerator(document);
+
+                    // Create the identifier syntax for the enum type, with the right annotations
+                    SyntaxNode enumTypeSyntax = syntaxGenerator.TypeExpression(enumTypeSymbol).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation);
+
+                    // Create the member access expression for the target enum type
+                    SyntaxNode enumMemberAccessExpressionSyntax = syntaxGenerator.MemberAccessExpression(enumTypeSyntax, memberName);
+
+                    // Create the attribute argument to insert
+                    SyntaxNode attributeArgumentSyntax = syntaxGenerator.AttributeArgument("DefaultValue", enumMemberAccessExpressionSyntax);
+
+                    // Actually add the argument to the existing attribute syntax
+                    return (AttributeListSyntax)syntaxGenerator.AddAttributeArguments(generatedDependencyPropertyAttributeList, [attributeArgumentSyntax]);
+                }
+            }
+
+            // Otherwise, just add the new default value normally
+            return
+                AttributeList(SingletonSeparatedList(
+                    generatedDependencyPropertyAttributeList.Attributes[0]
+                    .AddArgumentListArguments(
+                        AttributeArgument(ParseExpression(defaultValueExpression))
+                        .WithNameEquals(NameEquals(IdentifierName("DefaultValue"))))));
+        }
+
+        // If we have no value expression, we can just reuse the attribute with no changes
+        return generatedDependencyPropertyAttributeList;
+    }
+
     /// <summary>
     /// Applies the code fix to a target identifier and returns an updated document.
     /// </summary>
@@ -144,6 +209,8 @@ private static async Task<Document> ConvertToPartialProperty(
         SyntaxEditor syntaxEditor = new(root, document.Project.Solution.Workspace.Services);
 
         ConvertToPartialProperty(
+            document,
+            semanticModel,
             propertyDeclaration,
             fieldDeclaration,
             generatedDependencyPropertyAttributeList,
@@ -157,31 +224,29 @@ private static async Task<Document> ConvertToPartialProperty(
     /// <summary>
     /// Applies the code fix to a target identifier and returns an updated document.
     /// </summary>
+    /// <param name="document">The original document being fixed.</param>
+    /// <param name="semanticModel">The <see cref="SemanticModel"/> instance for the current compilation.</param>
     /// <param name="propertyDeclaration">The <see cref="PropertyDeclarationSyntax"/> for the property being updated.</param>
     /// <param name="fieldDeclaration">The <see cref="FieldDeclarationSyntax"/> for the declared property to remove.</param>
     /// <param name="generatedDependencyPropertyAttributeList">The <see cref="AttributeListSyntax"/> with the attribute to add.</param>
     /// <param name="syntaxEditor">The <see cref="SyntaxEditor"/> instance to use.</param>
     /// <param name="defaultValueExpression">The expression for the default value of the property, if present</param>
     /// <returns>An updated document with the applied code fix, and <paramref name="propertyDeclaration"/> being replaced with a partial property.</returns>
     private static void ConvertToPartialProperty(
+        Document document,
+        SemanticModel semanticModel,
         PropertyDeclarationSyntax propertyDeclaration,
         FieldDeclarationSyntax fieldDeclaration,
         AttributeListSyntax generatedDependencyPropertyAttributeList,
         SyntaxEditor syntaxEditor,
         string? defaultValueExpression)
     {
-        // If we do have a default value expression, set it in the attribute.
-        // We extract the generated attribute so we can add the new argument.
-        // It's important to reuse it, as it has the "add usings" annotation.
-        if (defaultValueExpression is not null)
-        {
-            generatedDependencyPropertyAttributeList =
-                AttributeList(SingletonSeparatedList(
-                    generatedDependencyPropertyAttributeList.Attributes[0]
-                    .AddArgumentListArguments(
-                        AttributeArgument(ParseExpression(defaultValueExpression))
-                        .WithNameEquals(NameEquals(IdentifierName("DefaultValue"))))));
-        }
+        // Update the attribute to insert with the default value, if present
+        generatedDependencyPropertyAttributeList = UpdateGeneratedDependencyPropertyAttributeList(
+            document,
+            semanticModel,
+            generatedDependencyPropertyAttributeList,
+            defaultValueExpression);
 
         // Start setting up the updated attribute lists
         SyntaxList<AttributeListSyntax> attributeLists = propertyDeclaration.AttributeLists;
@@ -295,6 +360,8 @@ private sealed class FixAllProvider : DocumentBasedFixAllProvider
                 string? defaultValue = diagnostic.Properties[UseGeneratedDependencyPropertyOnManualPropertyAnalyzer.DefaultValuePropertyName];
 
                 ConvertToPartialProperty(
+                    document,
+                    semanticModel,
                     propertyDeclaration,
                     fieldDeclaration,
                     generatedDependencyPropertyAttributeList,

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.SourceGenerators/Extensions/ITypeSymbolExtensions.cs

@@ -79,7 +79,7 @@ public static bool TryGetEnumFieldName(this ITypeSymbol symbol, object value, [N
                 continue;
             }
 
-            if (fieldValue == value)
+            if (fieldValue.Equals(value))
             {
                 fieldName = fieldSymbol.Name;
 

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.Tests/Test_UseGeneratedDependencyPropertyOnManualPropertyCodeFixer.cs

@@ -290,7 +290,9 @@ public partial class MyControl : Control
     [DataRow("int", "int", "42")]
     [DataRow("int?", "int?", "0")]
     [DataRow("int?", "int?", "42")]
-    [DataRow("global::Windows.UI.Xaml.Visibility", "global::Windows.UI.Xaml.Visibility", "global::Windows.UI.Xaml.Visibility.Collapsed")]
+    [DataRow("Visibility", "Visibility", "Visibility.Collapsed")]
+    [DataRow("global::MyApp.MyEnum", "global::MyApp.MyEnum", "(global::MyApp.MyEnum)5")]
+    [DataRow("global::MyApp.MyEnum", "global::MyApp.MyEnum", "(global::MyApp.MyEnum)(-5)")]
     public async Task SimpleProperty_WithExplicitValue_NotDefault(
         string dependencyPropertyType,
         string propertyType,
@@ -318,6 +320,8 @@ public partial class MyControl : Control
                     set => SetValue(NameProperty, value);
                 }
             }
+
+            public enum MyEnum { A }
             """;
 
         string @fixed = $$"""
@@ -334,6 +338,69 @@ public partial class MyControl : Control
                 [GeneratedDependencyProperty(DefaultValue = {{defaultValueExpression}})]
                 public partial {{propertyType}} {|CS9248:Name|} { get; set; }
             }
+
+            public enum MyEnum { A }
+            """;
+
+        CSharpCodeFixTest test = new(LanguageVersion.Preview)
+        {
+            TestCode = original,
+            FixedCode = @fixed,
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net80,
+            TestState = { AdditionalReferences =
+            {
+                MetadataReference.CreateFromFile(typeof(Point).Assembly.Location),
+                MetadataReference.CreateFromFile(typeof(ApplicationView).Assembly.Location),
+                MetadataReference.CreateFromFile(typeof(DependencyProperty).Assembly.Location),
+                MetadataReference.CreateFromFile(typeof(GeneratedDependencyPropertyAttribute).Assembly.Location)
+            }}
+        };
+
+        await test.RunAsync();
+    }
+
+    [TestMethod]
+    public async Task SimpleProperty_WithExplicitValue_NotDefault_AddsNamespace()
+    {
+        string original = $$"""
+            using Windows.UI.Xaml;
+            using Windows.UI.Xaml.Controls;
+
+            #nullable enable
+
+            namespace MyApp;
+
+            public partial class MyControl : Control
+            {
+                public static readonly DependencyProperty NameProperty = DependencyProperty.Register(
+                    name: "Name",
+                    propertyType: typeof(Windows.UI.Xaml.Automation.AnnotationType),
+                    ownerType: typeof(MyControl),
+                    typeMetadata: new PropertyMetadata(Windows.UI.Xaml.Automation.AnnotationType.TrackChanges));
+
+                public Windows.UI.Xaml.Automation.AnnotationType [|Name|]
+                {
+                    get => (Windows.UI.Xaml.Automation.AnnotationType)GetValue(NameProperty);
+                    set => SetValue(NameProperty, value);
+                }
+            }
+            """;
+
+        string @fixed = $$"""
+            using CommunityToolkit.WinUI;
+            using Windows.UI.Xaml;
+            using Windows.UI.Xaml.Automation;
+            using Windows.UI.Xaml.Controls;
+
+            #nullable enable
+
+            namespace MyApp;
+
+            public partial class MyControl : Control
+            {
+                [GeneratedDependencyProperty(DefaultValue = AnnotationType.TrackChanges)]
+                public partial Windows.UI.Xaml.Automation.AnnotationType {|CS9248:Name|} { get; set; }
+            }
             """;
 
         CSharpCodeFixTest test = new(LanguageVersion.Preview)