Preserve named constants in code fixer

Author: Sergio0694

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

@@ -46,8 +46,8 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         Diagnostic diagnostic = context.Diagnostics[0];
         TextSpan diagnosticSpan = context.Span;
 
-        // We can only possibly fix diagnostics with an additional location
-        if (diagnostic.AdditionalLocations is not [{ } fieldLocation])
+        // We always expect the field location to be the first additional location, this must be present
+        if (diagnostic.AdditionalLocations is not [{ } fieldLocation, ..])
         {
             return;
         }
@@ -62,6 +62,9 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         string? defaultValue = diagnostic.Properties[UseGeneratedDependencyPropertyOnManualPropertyAnalyzer.DefaultValuePropertyName];
         string? defaultValueTypeReferenceId = diagnostic.Properties[UseGeneratedDependencyPropertyOnManualPropertyAnalyzer.DefaultValueTypeReferenceIdPropertyName];
 
+        // Get any additional locations, if available
+        Location? defaultValueExpressionLocation = diagnostic.AdditionalLocations.ElementAtOrDefault(1);
+
         SyntaxNode? root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
 
         // Get the property declaration and the field declaration from the target diagnostic
@@ -82,7 +85,8 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                         propertyDeclaration,
                         fieldDeclaration,
                         defaultValue,
-                        defaultValueTypeReferenceId),
+                        defaultValueTypeReferenceId,
+                        defaultValueExpressionLocation),
                     equivalenceKey: "Use a partial property"),
                 diagnostic);
         }
@@ -123,21 +127,38 @@ private static bool TryGetGeneratedDependencyPropertyAttributeList(
     /// </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="root">The original tree root belonging to the current document.</param>
     /// <param name="defaultValueExpression">The expression for the default value of the property, if present</param>
-    /// <param name="defaultValueTypeFullyQualifiedMetadataName">The fully qualified metadata name of the default value, if present.</param>
+    /// <param name="defaultValueTypeReferenceId">The documentation comment reference id for type of the default value, if present.</param>
+    /// <param name="defaultValueExpressionLocation">The location for the default value, if available.</param>
     /// <returns>The updated attribute syntax.</returns>
     private static AttributeListSyntax UpdateGeneratedDependencyPropertyAttributeList(
         Document document,
         SemanticModel semanticModel,
+        SyntaxNode root,
         AttributeListSyntax generatedDependencyPropertyAttributeList,
         string? defaultValueExpression,
-        string? defaultValueTypeReferenceId)
+        string? defaultValueTypeReferenceId,
+        Location? defaultValueExpressionLocation)
     {
         // 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)
         {
+            SyntaxGenerator syntaxGenerator = SyntaxGenerator.GetGenerator(document);
+
+            // Special case if we have a location for the original expression, and we can resolve the node.
+            // In this case, we want to just carry that over with no changes (this is used for named constants).
+            // See notes below for how this method is constructing the new attribute argument to insert.
+            if (defaultValueExpressionLocation is not null &&
+                root.FindNode(defaultValueExpressionLocation.SourceSpan) is ArgumentSyntax { Expression: { } defaultValueOriginalExpression })
+            {
+                return (AttributeListSyntax)syntaxGenerator.AddAttributeArguments(
+                    generatedDependencyPropertyAttributeList,
+                    [syntaxGenerator.AttributeArgument("DefaultValue", defaultValueOriginalExpression)]);
+            }
+
             ExpressionSyntax parsedExpression = ParseExpression(defaultValueExpression);
 
             // Special case values which are simple enum member accesses, like 'global::Windows.UI.Xaml.Visibility.Collapsed'.
@@ -155,8 +176,6 @@ private static AttributeListSyntax UpdateGeneratedDependencyPropertyAttributeLis
                     Simplifier.AddImportsAnnotation,
                     new SyntaxAnnotation("SymbolId", defaultValueTypeReferenceId));
 
-                SyntaxGenerator syntaxGenerator = SyntaxGenerator.GetGenerator(document);
-
                 // Create the attribute argument to insert
                 SyntaxNode attributeArgumentSyntax = syntaxGenerator.AttributeArgument("DefaultValue", parsedExpression);
 
@@ -178,8 +197,6 @@ private static AttributeListSyntax UpdateGeneratedDependencyPropertyAttributeLis
                 // 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(fullyQualifiedMetadataName) 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);
 
@@ -215,7 +232,8 @@ private static AttributeListSyntax UpdateGeneratedDependencyPropertyAttributeLis
     /// <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="defaultValueExpression">The expression for the default value of the property, if present</param>
-    /// <param name="defaultValueTypeFullyQualifiedMetadataName">The fully qualified metadata name of the default value, if present.</param>
+    /// <param name="defaultValueTypeReferenceId">The documentation comment reference id for type of the default value, if present.</param>
+    /// <param name="defaultValueExpressionLocation">The location for the default value, if available.</param>
     /// <returns>An updated document with the applied code fix, and <paramref name="propertyDeclaration"/> being replaced with a partial property.</returns>
     private static async Task<Document> ConvertToPartialProperty(
         Document document,
@@ -224,7 +242,8 @@ private static async Task<Document> ConvertToPartialProperty(
         PropertyDeclarationSyntax propertyDeclaration,
         FieldDeclarationSyntax fieldDeclaration,
         string? defaultValueExpression,
-        string? defaultValueTypeReferenceId)
+        string? defaultValueTypeReferenceId,
+        Location? defaultValueExpressionLocation)
     {
         await Task.CompletedTask;
 
@@ -240,12 +259,14 @@ private static async Task<Document> ConvertToPartialProperty(
         ConvertToPartialProperty(
             document,
             semanticModel,
+            root,
             propertyDeclaration,
             fieldDeclaration,
             generatedDependencyPropertyAttributeList,
             syntaxEditor,
             defaultValueExpression,
-            defaultValueTypeReferenceId);
+            defaultValueTypeReferenceId,
+            defaultValueExpressionLocation);
 
         RemoveLeftoverLeadingEndOfLines([fieldDeclaration], syntaxEditor);
 
@@ -258,22 +279,26 @@ private static async Task<Document> ConvertToPartialProperty(
     /// </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="root">The original tree root belonging to the current document.</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>
-    /// <param name="defaultValueTypeFullyQualifiedMetadataName">The fully qualified metadata name of the default value, if present.</param>
+    /// <param name="defaultValueTypeReferenceId">The documentation comment reference id for type of the default value, if present.</param>
+    /// <param name="defaultValueExpressionLocation">The location for the default value, if available.</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,
+        SyntaxNode root,
         PropertyDeclarationSyntax propertyDeclaration,
         FieldDeclarationSyntax fieldDeclaration,
         AttributeListSyntax generatedDependencyPropertyAttributeList,
         SyntaxEditor syntaxEditor,
         string? defaultValueExpression,
-        string? defaultValueTypeReferenceId)
+        string? defaultValueTypeReferenceId,
+        Location? defaultValueExpressionLocation)
     {
         // Replace the property with the partial property using the attribute. Note that it's important to use the
         // lambda 'ReplaceNode' overload here, rather than creating a modifier property declaration syntax node and
@@ -287,9 +312,11 @@ private static void ConvertToPartialProperty(
             generatedDependencyPropertyAttributeList = UpdateGeneratedDependencyPropertyAttributeList(
                 document,
                 semanticModel,
+                root,
                 generatedDependencyPropertyAttributeList,
                 defaultValueExpression,
-                defaultValueTypeReferenceId);
+                defaultValueTypeReferenceId,
+                defaultValueExpressionLocation);
 
             // Start setting up the updated attribute lists
             SyntaxList<AttributeListSyntax> attributeLists = propertyDeclaration.AttributeLists;
@@ -482,26 +509,30 @@ private sealed class FixAllProvider : DocumentBasedFixAllProvider
                 }
 
                 // Also check that we can find the target field to remove
-                if (diagnostic.AdditionalLocations is not [{ } fieldLocation] ||
+                if (diagnostic.AdditionalLocations is not [{ } fieldLocation, ..] ||
                     root.FindNode(fieldLocation.SourceSpan) is not FieldDeclarationSyntax fieldDeclaration)
                 {
                     continue;
                 }
 
                 // Retrieve the properties passed by the analyzer
                 string? defaultValue = diagnostic.Properties[UseGeneratedDependencyPropertyOnManualPropertyAnalyzer.DefaultValuePropertyName];
-                string? defaultValueTypeFullyQualifiedMetadataName = diagnostic.Properties[UseGeneratedDependencyPropertyOnManualPropertyAnalyzer.DefaultValueTypeReferenceIdPropertyName];
+                string? defaultValueTypeReferenceId = diagnostic.Properties[UseGeneratedDependencyPropertyOnManualPropertyAnalyzer.DefaultValueTypeReferenceIdPropertyName];
 
+                // Get any additional locations, if available
+                Location? defaultValueExpressionLocation = diagnostic.AdditionalLocations.ElementAtOrDefault(1);
 
                 ConvertToPartialProperty(
                     document,
                     semanticModel,
+                    root,
                     propertyDeclaration,
                     fieldDeclaration,
                     generatedDependencyPropertyAttributeList,
                     syntaxEditor,
                     defaultValue,
-                    defaultValueTypeFullyQualifiedMetadataName);
+                    defaultValueTypeReferenceId,
+                    defaultValueExpressionLocation);
 
                 fieldDeclarations.Add(fieldDeclaration);
             }

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.SourceGenerators/Diagnostics/Analyzers/UseGeneratedDependencyPropertyOnManualPropertyAnalyzer.cs

@@ -486,6 +486,14 @@ void HandleSetAccessor(IPropertySymbol propertySymbol, PropertyFlags propertyFla
                                         fieldFlags.DefaultValueTypeReferenceId = DocumentationCommentId.CreateReferenceId(operandType);
                                     }
                                 }
+
+                                // Special case for named constants: in this case we want to carry the whole expression over, rather
+                                // than serializing the constant value itself. This preserves the actual fields being referenced.
+                                // We skip enum fields, as those are not named constants. Those will be handled by the logic above.
+                                if (conversionOperation.Operand is IFieldReferenceOperation { Field: { IsConst: true, ContainingType.TypeKind: not TypeKind.Enum } })
+                                {
+                                    fieldFlags.DefaultValueExpressionLocation = conversionOperation.Operand.Syntax.GetLocation();
+                                }
                             }
                             else if (conversionOperation.Operand is IFieldReferenceOperation { Field: { ContainingType.SpecialType: SpecialType.System_String, Name: "Empty" } })
                             {
@@ -573,7 +581,7 @@ void HandleSetAccessor(IPropertySymbol propertySymbol, PropertyFlags propertyFla
                             context.ReportDiagnostic(Diagnostic.Create(
                                 UseGeneratedDependencyPropertyForManualProperty,
                                 pair.Key.Locations.FirstOrDefault(),
-                                [fieldLocation],
+                                ((Location?[])[fieldLocation, fieldFlags.DefaultValueExpressionLocation]).OfType<Location>(),
                                 ImmutableDictionary.Create<string, string?>()
                                     .Add(DefaultValuePropertyName, fieldFlags.DefaultValue?.ToString())
                                     .Add(DefaultValueTypeReferenceIdPropertyName, fieldFlags.DefaultValueTypeReferenceId),
@@ -598,6 +606,7 @@ void HandleSetAccessor(IPropertySymbol propertySymbol, PropertyFlags propertyFla
                         fieldFlags.PropertyType = null;
                         fieldFlags.DefaultValue = null;
                         fieldFlags.DefaultValueTypeReferenceId = null;
+                        fieldFlags.DefaultValueExpressionLocation = null;
                         fieldFlags.FieldLocation = null;
 
                         fieldFlagsStack.Push(fieldFlags);
@@ -677,6 +686,11 @@ private sealed class FieldFlags
         /// </summary>
         public string? DefaultValueTypeReferenceId;
 
+        /// <summary>
+        /// The location for the default value, if available.
+        /// </summary>
+        public Location? DefaultValueExpressionLocation;
+
         /// <summary>
         /// The location of the target field being initialized.
         /// </summary>

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

@@ -544,6 +544,96 @@ public partial class MyControl : Control
         await test.RunAsync();
     }
 
+    [TestMethod]
+    [DataRow("int", "MyContainer1.X")]
+    [DataRow("float", "MyContainer1.Y")]
+    [DataRow("string", "MyContainer1.S")]
+    [DataRow("MyContainer1.MyContainer2.NestedEnum", "MyContainer1.E1")]
+    [DataRow("MyContainer1.MyEnum1", "MyContainer1.E2")]
+    [DataRow("MyEnum3", "MyContainer1.E3")]
+    [DataRow("int", "MyContainer1.MyContainer2.X")]
+    [DataRow("float", "MyContainer1.MyContainer2.Y")]
+    [DataRow("string", "MyContainer1.MyContainer2.S")]
+    [DataRow("MyContainer1.MyContainer2.NestedEnum", "MyContainer1.MyContainer2.E1")]
+    [DataRow("MyContainer1.MyEnum1", "MyContainer1.MyContainer2.E2")]
+    [DataRow("MyEnum3", "MyContainer1.MyContainer2.E3")]
+    public async Task SimpleProperty_WithExplicitValue_NamedConstant(string propertyType, string defaultValue)
+    {
+        const string types = """
+            public class MyContainer1
+            {
+                public const int X = 42;
+                public const float Y = 3.14f;
+                public const string S = "Test";
+                public const MyContainer2.NestedEnum E1 = MyContainer2.NestedEnum.B;
+                public const MyEnum1 E2 = MyEnum1.B;
+                public const MyEnum3 E3 = MyEnum3.B;
+
+                public enum MyEnum1 { A, B };
+
+                public struct MyContainer2
+                {
+                    public const int X = 42;
+                    public const float Y = 3.14f;
+                    public const string S = "Test";
+                    public const NestedEnum E1 = NestedEnum.B;
+                    public const MyEnum1 E2 = MyEnum1.B;
+                    public const MyEnum3 E3 = MyEnum3.B;
+
+                    public enum NestedEnum { A, B };
+                }
+            }
+
+            public enum MyEnum3 { A, B }
+            """;
+
+        string original = $$"""
+            using Windows.UI.Xaml;
+
+            namespace MyApp;
+
+            public class MyObject : DependencyObject
+            {
+                public static readonly DependencyProperty NameProperty = DependencyProperty.Register(
+                    name: "Name",
+                    propertyType: typeof({{propertyType}}),
+                    ownerType: typeof(MyObject),
+                    typeMetadata: new PropertyMetadata({{defaultValue}}));
+
+                public {{propertyType}} [|Name|]
+                {
+                    get => ({{propertyType}})GetValue(NameProperty);
+                    set => SetValue(NameProperty, value);
+                }
+            }
+
+            {{types}}
+            """;
+
+        string @fixed = $$"""
+            using CommunityToolkit.WinUI;
+            using Windows.UI.Xaml;
+
+            namespace MyApp;
+
+            public partial class MyObject : DependencyObject
+            {
+                [GeneratedDependencyProperty(DefaultValue = {{defaultValue}})]
+                public partial {{propertyType}} {|CS9248:Name|} { get; set; }
+            }
+
+            {{types}}
+            """;
+
+        CSharpCodeFixTest test = new(LanguageVersion.Preview)
+        {
+            TestCode = original,
+            FixedCode = @fixed
+        };
+
+        await test.RunAsync();
+    }
+
     [TestMethod]
     [DataRow("[A]", "[static: A]")]
     [DataRow("""[Test(42, "Hello")]""", """[static: Test(42, "Hello")]""")]