Add validation for CompletedTaskAttribute on non-readonly fields and properties with non-private setters

Co-authored-by: drewnoakes <350947+drewnoakes@users.noreply.github.com>

Author: Copilot

docfx/analyzers/VSTHRD003.md

@@ -26,6 +26,10 @@ async Task MyMethodAsync()
 }
 ```
 
+**Important restrictions:**
+- Fields must be marked `readonly` when using this attribute
+- Properties must not have non-private setters (getter-only or private setters are allowed)
+
 ### Marking external types
 
 You can also apply the attribute at the assembly level to mark members in external types that you don't control:

src/Microsoft.VisualStudio.Threading.Analyzers.CSharp/VSTHRD003UseJtfRunAsyncAnalyzer.cs

@@ -83,6 +83,24 @@ private static bool IsSymbolAlwaysOkToAwait(ISymbol? symbol, Compilation compila
             attr.AttributeClass?.Name == Types.CompletedTaskAttribute.TypeName &&
             attr.AttributeClass.BelongsToNamespace(Types.CompletedTaskAttribute.Namespace)))
         {
+            // Validate that the attribute is used correctly
+            if (symbol is IFieldSymbol fieldSymbol)
+            {
+                // Fields must be readonly
+                if (!fieldSymbol.IsReadOnly)
+                {
+                    return false;
+                }
+            }
+            else if (symbol is IPropertySymbol propertySymbol)
+            {
+                // Properties must not have non-private setters
+                if (propertySymbol.SetMethod is not null && propertySymbol.SetMethod.DeclaredAccessibility != Accessibility.Private)
+                {
+                    return false;
+                }
+            }
+
             return true;
         }
 

test/Microsoft.VisualStudio.Threading.Analyzers.Tests/VSTHRD003UseJtfRunAsyncAnalyzerTests.cs

@@ -1852,6 +1852,146 @@ async Task TestMethod()
         await CSVerify.VerifyAnalyzerAsync(test);
     }
 
+    [Fact]
+    public async Task ReportWarningWhenCompletedTaskAttributeOnNonReadonlyField()
+    {
+        var test = @"
+using System.Threading.Tasks;
+
+namespace Microsoft.VisualStudio.Threading
+{
+    [System.AttributeUsage(System.AttributeTargets.Property | System.AttributeTargets.Method | System.AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
+    internal sealed class CompletedTaskAttribute : System.Attribute
+    {
+    }
+}
+
+class Tests
+{
+    [Microsoft.VisualStudio.Threading.CompletedTask]
+    private static Task MyTask = Task.CompletedTask; // Not readonly
+
+    async Task GetTask()
+    {
+        await [|MyTask|];
+    }
+}
+";
+        await CSVerify.VerifyAnalyzerAsync(test);
+    }
+
+    [Fact]
+    public async Task ReportWarningWhenCompletedTaskAttributeOnPropertyWithPublicSetter()
+    {
+        var test = @"
+using System.Threading.Tasks;
+
+namespace Microsoft.VisualStudio.Threading
+{
+    [System.AttributeUsage(System.AttributeTargets.Property | System.AttributeTargets.Method | System.AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
+    internal sealed class CompletedTaskAttribute : System.Attribute
+    {
+    }
+}
+
+class Tests
+{
+    [Microsoft.VisualStudio.Threading.CompletedTask]
+    public static Task MyTask { get; set; } = Task.CompletedTask; // Public setter
+
+    async Task GetTask()
+    {
+        await [|MyTask|];
+    }
+}
+";
+        await CSVerify.VerifyAnalyzerAsync(test);
+    }
+
+    [Fact]
+    public async Task ReportWarningWhenCompletedTaskAttributeOnPropertyWithInternalSetter()
+    {
+        var test = @"
+using System.Threading.Tasks;
+
+namespace Microsoft.VisualStudio.Threading
+{
+    [System.AttributeUsage(System.AttributeTargets.Property | System.AttributeTargets.Method | System.AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
+    internal sealed class CompletedTaskAttribute : System.Attribute
+    {
+    }
+}
+
+class Tests
+{
+    [Microsoft.VisualStudio.Threading.CompletedTask]
+    public static Task MyTask { get; internal set; } = Task.CompletedTask; // Internal setter
+
+    async Task GetTask()
+    {
+        await [|MyTask|];
+    }
+}
+";
+        await CSVerify.VerifyAnalyzerAsync(test);
+    }
+
+    [Fact]
+    public async Task DoNotReportWarningWhenCompletedTaskAttributeOnPropertyWithPrivateSetter()
+    {
+        var test = @"
+using System.Threading.Tasks;
+
+namespace Microsoft.VisualStudio.Threading
+{
+    [System.AttributeUsage(System.AttributeTargets.Property | System.AttributeTargets.Method | System.AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
+    internal sealed class CompletedTaskAttribute : System.Attribute
+    {
+    }
+}
+
+class Tests
+{
+    [Microsoft.VisualStudio.Threading.CompletedTask]
+    public static Task MyTask { get; private set; } = Task.CompletedTask; // Private setter is OK
+
+    async Task GetTask()
+    {
+        await MyTask;
+    }
+}
+";
+        await CSVerify.VerifyAnalyzerAsync(test);
+    }
+
+    [Fact]
+    public async Task DoNotReportWarningWhenCompletedTaskAttributeOnPropertyWithGetterOnly()
+    {
+        var test = @"
+using System.Threading.Tasks;
+
+namespace Microsoft.VisualStudio.Threading
+{
+    [System.AttributeUsage(System.AttributeTargets.Property | System.AttributeTargets.Method | System.AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
+    internal sealed class CompletedTaskAttribute : System.Attribute
+    {
+    }
+}
+
+class Tests
+{
+    [Microsoft.VisualStudio.Threading.CompletedTask]
+    public static Task MyTask { get; } = Task.CompletedTask; // Getter-only is OK
+
+    async Task GetTask()
+    {
+        await MyTask;
+    }
+}
+";
+        await CSVerify.VerifyAnalyzerAsync(test);
+    }
+
     private DiagnosticResult CreateDiagnostic(int line, int column, int length) =>
         CSVerify.Diagnostic().WithSpan(line, column, line, column + length);
 }