Add 'UseFieldDeclarationCorrectlyAnalyzer' and tests

Author: Sergio0694

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.SourceGenerators/AnalyzerReleases.Shipped.md

@@ -26,3 +26,4 @@ WCTDP0016 | CommunityToolkit.GeneratedDependencyPropertyDependencyPropertyGenera
 WCTDP0017 | CommunityToolkit.GeneratedDependencyPropertyDependencyPropertyGenerator | Info |
 WCTDP0018 | CommunityToolkit.GeneratedDependencyPropertyDependencyPropertyGenerator | Error |
 WCTDP0019 | CommunityToolkit.GeneratedDependencyPropertyDependencyPropertyGenerator | Error |
+WCTDP0020 | CommunityToolkit.GeneratedDependencyPropertyDependencyPropertyGenerator | Warning |

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

@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Linq;
+using CommunityToolkit.GeneratedDependencyProperty.Constants;
+using CommunityToolkit.GeneratedDependencyProperty.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using static CommunityToolkit.GeneratedDependencyProperty.Diagnostics.DiagnosticDescriptors;
+
+namespace CommunityToolkit.GeneratedDependencyProperty;
+
+/// <summary>
+/// A diagnostic analyzer that generates a warning whenever a dependency property is declared as an incorrect field.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class UseFieldDeclarationCorrectlyAnalyzer : DiagnosticAnalyzer
+{
+    /// <inheritdoc/>
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = [IncorrectDependencyPropertyFieldDeclaration];
+
+    /// <inheritdoc/>
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+
+
+        context.RegisterCompilationStartAction(static context =>
+        {
+            // Get the XAML mode to use
+            bool useWindowsUIXaml = context.Options.AnalyzerConfigOptionsProvider.GlobalOptions.GetMSBuildBooleanPropertyValue(WellKnownPropertyNames.DependencyPropertyGeneratorUseWindowsUIXaml);
+
+            // Get the 'DependencyProperty' symbol
+            if (context.Compilation.GetTypeByMetadataName(WellKnownTypeNames.DependencyProperty(useWindowsUIXaml)) is not { } dependencyPropertySymbol)
+            {
+                return;
+            }
+
+            context.RegisterSymbolAction(context =>
+            {
+                IFieldSymbol fieldSymbol = (IFieldSymbol)context.Symbol;
+
+                // We only care about fields with are of type 'DependencyProperty'
+                if (!SymbolEqualityComparer.Default.Equals(fieldSymbol.Type, dependencyPropertySymbol))
+                {
+                    return;
+                }
+
+                // Fields should always be public, static, readonly, and with nothing else on them
+                if (fieldSymbol is
+                    { DeclaredAccessibility: not Accessibility.Public } or
+                    { IsStatic: false } or
+                    { IsRequired: true } or
+                    { IsReadOnly: false } or
+                    { IsVolatile: true } or
+                    { NullableAnnotation: NullableAnnotation.Annotated })
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        IncorrectDependencyPropertyFieldDeclaration,
+                        fieldSymbol.Locations.FirstOrDefault(),
+                        fieldSymbol));
+                }
+            }, SymbolKind.Field);
+        });
+    }
+}

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

@@ -66,7 +66,6 @@ public override void Initialize(AnalysisContext context)
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
 
-
         context.RegisterCompilationStartAction(static context =>
         {
             // Get the XAML mode to use

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs

@@ -262,4 +262,17 @@ internal static class DiagnosticDescriptors
         isEnabledByDefault: true,
         description: "All attributes targeting the generated dependency property for a property annotated with [GeneratedDependencyProperty] must have arguments using supported expressions.",
         helpLinkUri: "https://aka.ms/toolkit/labs/windows");
+
+    /// <summary>
+    /// <c>"The field '{0}' is a dependency property, but it is not declared correctly (all dependency property fields should be declared as 'public static readonly', and not be nullable)"</c>.
+    /// </summary>
+    public static readonly DiagnosticDescriptor IncorrectDependencyPropertyFieldDeclaration = new(
+        id: "WCTDP0020",
+        title: "Incorrect dependency property field declaration",
+        messageFormat: "The field '{0}' is a dependency property, but it is not declared correctly (all dependency property fields should be declared as 'public static readonly', and not be nullable)",
+        category: typeof(DependencyPropertyGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "All dependency property fields should be declared as 'public static readonly', and not be nullable.",
+        helpLinkUri: "https://learn.microsoft.com/windows/uwp/xaml-platform/custom-dependency-properties#checklist-for-defining-a-dependency-property");
 }

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

@@ -1817,4 +1817,56 @@ public class TestAttribute(string P) : Attribute
 
         await CSharpAnalyzerTest<InvalidPropertyForwardedAttributeDeclarationAnalyzer>.VerifyAnalyzerAsync(source, LanguageVersion.CSharp13);
     }
+
+    [TestMethod]
+    public async Task UseFieldDeclarationCorrectlyAnalyzer_NotDependencyProperty_DoesNotWarn()
+    {
+        string source = $$"""
+            using Windows.UI.Xaml;
+
+            public class MyObject : DependencyObject
+            {
+                private static string TestProperty = "Blah";
+            }
+            """;
+
+        await CSharpAnalyzerTest<UseFieldDeclarationCorrectlyAnalyzer>.VerifyAnalyzerAsync(source, LanguageVersion.CSharp13);
+    }
+
+    [TestMethod]
+    public async Task UseFieldDeclarationCorrectlyAnalyzer_ValidField_DoesNotWarn()
+    {
+        const string source = """
+            using Windows.UI.Xaml;
+
+            public class MyObject : DependencyObject
+            {
+                public static readonly DependencyProperty TestProperty = DependencyProperty.Register("Test", typeof(string), typeof(MyObject), null);
+            }
+            """;
+
+        await CSharpAnalyzerTest<UseFieldDeclarationCorrectlyAnalyzer>.VerifyAnalyzerAsync(source, LanguageVersion.CSharp13);
+    }
+
+    [TestMethod]
+    [DataRow("private static readonly DependencyProperty")]
+    [DataRow("public readonly DependencyProperty")]
+    [DataRow("public static DependencyProperty")]
+    [DataRow("public static volatile DependencyProperty")]
+    [DataRow("public static readonly DependencyProperty?")]
+    public async Task UseFieldDeclarationCorrectlyAnalyzer_Warns(string fieldDeclaration)
+    {
+        string source = $$"""
+            using Windows.UI.Xaml;
+
+            #nullable enable
+            
+            public class MyObject : DependencyObject
+            {
+                {{fieldDeclaration}} {|WCTDP0020:TestProperty|};
+            }
+            """;
+
+        await CSharpAnalyzerTest<UseFieldDeclarationCorrectlyAnalyzer>.VerifyAnalyzerAsync(source, LanguageVersion.CSharp13);
+    }
 }