🧪 [Experiment] DependencyPropertyGenerator

.github/workflows/build.yml

@@ -354,4 +354,4 @@ jobs:
         if: ${{ (env.ENABLE_DIAGNOSTICS == 'true' || env.COREHOST_TRACE != '') && always() }}
         with:
           name: linux-logs
-          path: ./**/*.*log
+          path: ./**/*.*log

components/AppServices/src/CommunityToolkit.AppServices.csproj

@@ -6,7 +6,12 @@
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <RootNamespace>CommunityToolkit.AppServices</RootNamespace>
     <PackageId>$(PackageIdPrefix).$(ToolkitComponentName)</PackageId>
+    <HasWindowsUIXaml>false</HasWindowsUIXaml>
     <HasWinUI>false</HasWinUI>
+    <EnableXamlCompilerMismatchedTfmUnoWorkaround>false</EnableXamlCompilerMismatchedTfmUnoWorkaround>
+
+    <!-- This library doesn't need XAML support, so we can just target 17763 -->
+    <UwpTargetFrameworks>uap10.0.17763;net8.0-windows10.0.17763.0;net9.0-windows10.0.17763.0;</UwpTargetFrameworks>
   </PropertyGroup>
 
   <!-- Sets this up as a toolkit component's source project -->
@@ -29,7 +34,7 @@
   </PropertyGroup>
 
   <!-- Add the Desktop Extension SDK when on UWP-->
-  <ItemGroup Condition="'$(IsUwp)' == 'true' AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) != 'windows'">
+  <ItemGroup Condition="'$(IsUwp)' == 'true' AND '$(MultiTargetPlatformIdentifier)' != 'windows'">
     <SDKReference Include="WindowsDesktop, Version=$(TargetPlatformVersion)">
       <Name>Windows Desktop Extensions for the UWP</Name>
     </SDKReference>

components/DependencyPropertyGenerator/.gitattributes

@@ -0,0 +1,10 @@
+# All file types:
+#   - Treat as text
+#   - Normalize to LF line endings
+* text=auto eol=lf
+
+# Explicit settings for well known types
+*.cs           text      eol=lf
+*.csproj       text      eol=lf
+*.projitems    text      eol=lf
+*.shprroj      text      eol=lf

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.CodeFixers/CommunityToolkit.DependencyPropertyGenerator.CodeFixers.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+
+    <!-- We're intentionally not always matching the namespace with folder path, to better organize the code -->
+    <NoWarn>$(NoWarn);IDE0130</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.12.0" PrivateAssets="all" />
+    <PackageReference Include="PolySharp" Version="1.15.0" PrivateAssets="all" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CommunityToolkit.DependencyPropertyGenerator.SourceGenerators\CommunityToolkit.DependencyPropertyGenerator.SourceGenerators.csproj" />
+  </ItemGroup>
+</Project>

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.CodeFixers/UseFieldDeclarationCodeFixer.cs

@@ -0,0 +1,155 @@
+// 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.Composition;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Text;
+using static CommunityToolkit.GeneratedDependencyProperty.Diagnostics.DiagnosticDescriptors;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace CommunityToolkit.GeneratedDependencyProperty;
+
+/// <summary>
+/// A code fixer that updates property declarations to be fields instead, for dependency properties.
+/// </summary>
+[ExportCodeFixProvider(LanguageNames.CSharp)]
+[Shared]
+public sealed class UseFieldDeclarationCodeFixer : CodeFixProvider
+{
+    /// <inheritdoc/>
+    public override ImmutableArray<string> FixableDiagnosticIds { get; } = [DependencyPropertyFieldDeclarationId];
+
+    /// <inheritdoc/>
+    public override FixAllProvider? GetFixAllProvider()
+    {
+        return WellKnownFixAllProviders.BatchFixer;
+    }
+
+    /// <inheritdoc/>
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        Diagnostic diagnostic = context.Diagnostics[0];
+        TextSpan diagnosticSpan = context.Span;
+
+        SyntaxNode? root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+
+        // Get the property declaration from the target diagnostic
+        if (root!.FindNode(diagnosticSpan) is PropertyDeclarationSyntax propertyDeclaration)
+        {
+            // We only support this code fix for static properties without modifiers and attributes
+            if (!IsCodeFixSupportedForPropertyDeclaration(propertyDeclaration))
+            {
+                return;
+            }
+
+            // We can now register the code fix to convert the property into a field
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    title: "Declare dependency property as field",
+                    createChangedDocument: token => ConvertDependencyPropertyToFieldDeclaration(context.Document, root, propertyDeclaration),
+                    equivalenceKey: "Declare dependency property as field"),
+                diagnostic);
+        }
+    }
+
+    /// <summary>
+    /// Checks whether the code fixer can be applied to a target property declaration.
+    /// </summary>
+    /// <param name="propertyDeclaration">The <see cref="PropertyDeclarationSyntax"/> to update.</param>
+    /// <returns>Whether the code fixer can be applied to <paramref name="propertyDeclaration"/>.</returns>
+    private static bool IsCodeFixSupportedForPropertyDeclaration(PropertyDeclarationSyntax propertyDeclaration)
+    {
+        // We don't support properties with attributes, as those might not work on fields and need special handling
+        if (propertyDeclaration.AttributeLists.Count > 0)
+        {
+            return false;
+        }
+
+        foreach (SyntaxToken modifier in propertyDeclaration.Modifiers)
+        {
+            // Accessibility modifiers are allowed (the property will however become public)
+            if (SyntaxFacts.IsAccessibilityModifier(modifier.Kind()))
+            {
+                continue;
+            }
+
+            // If the property is abstract or an override, or other weird things (which shouldn't really happen), we don't support it
+            if (modifier.Kind() is SyntaxKind.AbstractKeyword or SyntaxKind.OverrideKeyword or SyntaxKind.PartialKeyword or SyntaxKind.ExternKeyword)
+            {
+                return false;
+            }
+        }
+
+        // Properties with an expression body are supported and will be converted to field initializers
+        if (propertyDeclaration.ExpressionBody is not null)
+        {
+            return true;
+        }
+
+        // The property must have at least an accessor
+        if (propertyDeclaration.AccessorList is not { Accessors.Count: > 0 } accessorList)
+        {
+            return false;
+        }
+
+        // One of the accessors must be a getter
+        if (!accessorList.Accessors.Any(accessor => accessor.IsKind(SyntaxKind.GetAccessorDeclaration)))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Applies the code fix to a target property declaration and returns an updated document.
+    /// </summary>
+    /// <param name="document">The original document being fixed.</param>
+    /// <param name="root">The original tree root belonging to the current document.</param>
+    /// <param name="propertyDeclaration">The <see cref="PropertyDeclarationSyntax"/> to update.</param>
+    /// <returns>An updated document with the applied code fix.</returns>
+    private static async Task<Document> ConvertDependencyPropertyToFieldDeclaration(Document document, SyntaxNode root, PropertyDeclarationSyntax propertyDeclaration)
+    {
+        await Task.CompletedTask;
+
+        SyntaxEditor syntaxEditor = new(root, document.Project.Solution.Workspace.Services);
+
+        syntaxEditor.ReplaceNode(propertyDeclaration, (node, generator) =>
+        {
+            // If the property had an initializer, carry that over
+            ExpressionSyntax? initializerExpression = propertyDeclaration switch
+            {
+                { ExpressionBody.Expression: { } arrowExpression } => arrowExpression,
+                { Initializer.Value: { } equalsExpression } => equalsExpression,
+                _ => null
+            };
+
+            // Create the field declaration and make it 'public static readonly' (same as the other analyzer)
+            SyntaxNode updatedNode = generator.FieldDeclaration(
+                name: propertyDeclaration.Identifier.Text,
+                type: propertyDeclaration.Type,
+                accessibility: Accessibility.Public,
+                modifiers: DeclarationModifiers.Static | DeclarationModifiers.ReadOnly,
+                initializer: initializerExpression);
+
+            // Keep the 'new' modifier, if needed
+            if (propertyDeclaration.Modifiers.Any(SyntaxKind.NewKeyword))
+            {
+                updatedNode = generator.WithModifiers(updatedNode, generator.GetModifiers(updatedNode).WithIsNew(true));
+            }
+
+            return updatedNode.WithTriviaFrom(propertyDeclaration);
+        });
+
+        return document.WithSyntaxRoot(syntaxEditor.GetChangedRoot());
+    }
+}

components/DependencyPropertyGenerator/CommunityToolkit.DependencyPropertyGenerator.CodeFixers/UseFieldDeclarationCorrectlyCodeFixer.cs

@@ -0,0 +1,94 @@
+// 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.Composition;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Text;
+using static CommunityToolkit.GeneratedDependencyProperty.Diagnostics.DiagnosticDescriptors;
+
+namespace CommunityToolkit.GeneratedDependencyProperty;
+
+/// <summary>
+/// A code fixer that updates field declarations to ensure they follow the recommended rules for dependency properties.
+/// </summary>
+[ExportCodeFixProvider(LanguageNames.CSharp)]
+[Shared]
+public sealed class UseFieldDeclarationCorrectlyCodeFixer : CodeFixProvider
+{
+    /// <inheritdoc/>
+    public override ImmutableArray<string> FixableDiagnosticIds { get; } = [IncorrectDependencyPropertyFieldDeclarationId];
+
+    /// <inheritdoc/>
+    public override FixAllProvider? GetFixAllProvider()
+    {
+        return WellKnownFixAllProviders.BatchFixer;
+    }
+
+    /// <inheritdoc/>
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        Diagnostic diagnostic = context.Diagnostics[0];
+        TextSpan diagnosticSpan = context.Span;
+
+        SyntaxNode? root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+
+        // Get the the field declaration from the target diagnostic
+        if (root!.FindNode(diagnosticSpan).FirstAncestorOrSelf<FieldDeclarationSyntax>() is { } fieldDeclaration)
+        {
+            // Register the code fix to update the field to be correctly declared
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    title: "Declare dependency property field correctly",
+                    createChangedDocument: token => FixDependencyPropertyFieldDeclaration(context.Document, root, fieldDeclaration),
+                    equivalenceKey: "Declare dependency property field correctly"),
+                diagnostic);
+        }
+    }
+
+    /// <summary>
+    /// Applies the code fix to a target field declaration and returns an updated document.
+    /// </summary>
+    /// <param name="document">The original document being fixed.</param>
+    /// <param name="root">The original tree root belonging to the current document.</param>
+    /// <param name="fieldDeclaration">The <see cref="FieldDeclarationSyntax"/> to update.</param>
+    /// <returns>An updated document with the applied code fix.</returns>
+    private static async Task<Document> FixDependencyPropertyFieldDeclaration(Document document, SyntaxNode root, FieldDeclarationSyntax fieldDeclaration)
+    {
+        await Task.CompletedTask;
+
+        SyntaxEditor syntaxEditor = new(root, document.Project.Solution.Workspace.Services);
+
+        // We use the lambda overload mostly for convenient, so we can easily get a generator to use
+        syntaxEditor.ReplaceNode(fieldDeclaration, (node, generator) =>
+        {
+            // Keep the original node to get the trivia back from it
+            SyntaxNode originalNode = node;
+
+            // Update the field to ensure it's declared as 'public static readonly'
+            node = generator.WithAccessibility(node, Accessibility.Public);
+            node = generator.WithModifiers(node, DeclarationModifiers.Static | DeclarationModifiers.ReadOnly);
+
+            // If the type is declared as nullable, unwrap it and remove the annotation.
+            // We need to make sure to carry the space after the element type. When the
+            // type is nullable, that space is attached to the question mark token.
+            if (((FieldDeclarationSyntax)node).Declaration is { Type: NullableTypeSyntax { ElementType: { } fieldElementType } nullableType } variableDeclaration)
+            {
+                TypeSyntax typeDeclaration = fieldElementType.WithTrailingTrivia(nullableType.QuestionToken.TrailingTrivia);
+
+                node = ((FieldDeclarationSyntax)node).WithDeclaration(variableDeclaration.WithType(typeDeclaration));
+            }
+
+            return node.WithTriviaFrom(originalNode);
+        });
+
+        // Create the new document with the single change
+        return document.WithSyntaxRoot(syntaxEditor.GetChangedRoot());
+    }
+}