Support target-typed 'new()' expressions for metadata

Author: Sergio0694

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

@@ -512,7 +512,16 @@ void HandleSetAccessor(IPropertySymbol propertySymbol, PropertyFlags propertyFla
                         // Next, check if the argument is 'new PropertyMetadata(...)' with the default value for the property type
                         if (propertyMetadataArgument.Value is not IObjectCreationOperation { Arguments: [{ } defaultValueArgument, ..] } objectCreationOperation)
                         {
-                            return;
+                            // Before failing, check whether the argument is 'new (...)`. In this case, the target type is 'PropertyMetadata' anyway,
+                            // which we also validate right after this check as well anyway. With 'new()', we expect a conversion operation instead.
+                            if (propertyMetadataArgument.Value is not IConversionOperation { IsImplicit: true } objectCreationConversionOperation ||
+                                objectCreationConversionOperation.Operand is not IObjectCreationOperation { Arguments: [_, ..] } conversionObjectCreationOperation)
+                            {
+                                return;
+                            }
+
+                            defaultValueArgument = conversionObjectCreationOperation.Arguments[0];
+                            objectCreationOperation = conversionObjectCreationOperation;
                         }
 
                         // Make sure the object being created is actually 'PropertyMetadata'

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.Tests/Test_Analyzers.cs

@@ -3338,6 +3338,35 @@ public partial class MyObject<T, TOther> : DependencyObject {{typeConstraints}}
         await CSharpAnalyzerTest<UseGeneratedDependencyPropertyOnManualPropertyAnalyzer>.VerifyAnalyzerAsync(source, LanguageVersion.CSharp13);
     }
 
+    // Regression test for a case found in the Microsoft Store
+    [TestMethod]
+    public async Task UseGeneratedDependencyPropertyOnManualPropertyAnalyzer_ValidProperty_WithTargetTypedPropertyMetadataNew_Warns()
+    {
+        const string source = """
+            using Windows.Foundation;
+            using Windows.UI.Xaml;
+            
+            namespace MyApp;
+
+            public class MyObject : DependencyObject
+            {
+                public static readonly DependencyProperty VisibleAreaProperty = DependencyProperty.Register(
+                    nameof(VisibleArea),
+                    typeof(Rect),
+                    typeof(MyObject),
+                    new(default(Rect)));
+
+                public Rect {|WCTDPG0017:VisibleArea|}
+                {
+                    get => (Rect)GetValue(VisibleAreaProperty);
+                    private set => SetValue(VisibleAreaProperty, value);
+                }
+            }
+            """;
+
+        await CSharpAnalyzerTest<UseGeneratedDependencyPropertyOnManualPropertyAnalyzer>.VerifyAnalyzerAsync(source, LanguageVersion.CSharp13);
+    }
+
     [TestMethod]
     [DataRow("where T : struct")]
     [DataRow("where T : unmanaged")]

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

@@ -2755,4 +2755,54 @@ public enum MyEnum { A, B }
 
         await test.RunAsync();
     }
+
+    // Regression test for a case found in the Microsoft Store
+    [TestMethod]
+    public async Task SimpleProperty_WithTargetTypedPropertyMetadataNew()
+    {
+        const string original = """
+            using Windows.Foundation;
+            using Windows.UI.Xaml;
+            
+            namespace MyApp;
+
+            public class MyObject : DependencyObject
+            {
+                public static readonly DependencyProperty VisibleAreaProperty = DependencyProperty.Register(
+                    nameof(VisibleArea),
+                    typeof(Rect),
+                    typeof(MyObject),
+                    new(default(Rect)));
+
+                public Rect {|WCTDPG0017:VisibleArea|}
+                {
+                    get => (Rect)GetValue(VisibleAreaProperty);
+                    private set => SetValue(VisibleAreaProperty, value);
+                }
+            }
+            """;
+
+        const string @fixed = """
+            using CommunityToolkit.WinUI;
+            using Windows.Foundation;
+            using Windows.UI.Xaml;
+
+            namespace MyApp;
+
+            public partial class MyObject : DependencyObject
+            {
+                [GeneratedDependencyProperty]
+                public partial Rect {|CS9248:VisibleArea|} { get; private set; }
+            }
+            """;
+
+        CSharpCodeFixTest test = new(LanguageVersion.Preview)
+        {
+            TestCode = original,
+            FixedCode = @fixed,
+            MarkupOptions = MarkupOptions.UseFirstDescriptor
+        };
+
+        await test.RunAsync();
+    }
 }