Update 'use compound expr' to support 'field keyword' (#76639)

Author: CyrusNajmabadi

src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundAssignmentDiagnosticAnalyzer.cs

@@ -11,14 +11,10 @@
 namespace Microsoft.CodeAnalysis.CSharp.UseCompoundAssignment;
 
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
-internal class CSharpUseCompoundAssignmentDiagnosticAnalyzer
-    : AbstractUseCompoundAssignmentDiagnosticAnalyzer<SyntaxKind, AssignmentExpressionSyntax, BinaryExpressionSyntax>
+internal sealed class CSharpUseCompoundAssignmentDiagnosticAnalyzer()
+    : AbstractUseCompoundAssignmentDiagnosticAnalyzer<SyntaxKind, AssignmentExpressionSyntax, BinaryExpressionSyntax>(
+        CSharpSyntaxFacts.Instance, Utilities.Kinds)
 {
-    public CSharpUseCompoundAssignmentDiagnosticAnalyzer()
-        : base(CSharpSyntaxFacts.Instance, Utilities.Kinds)
-    {
-    }
-
     protected override SyntaxKind GetAnalysisKind()
         => SyntaxKind.SimpleAssignmentExpression;
 

src/Analyzers/CSharp/Analyzers/UseCompoundAssignment/CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer.cs

@@ -25,17 +25,13 @@ namespace Microsoft.CodeAnalysis.CSharp.UseCompoundAssignment;
 /// </list>
 /// </summary>
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
-internal class CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer
-    : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+internal sealed class CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer()
+    : AbstractBuiltInCodeStyleDiagnosticAnalyzer(
+        IDEDiagnosticIds.UseCoalesceCompoundAssignmentDiagnosticId,
+        EnforceOnBuildValues.UseCoalesceCompoundAssignment,
+        CodeStyleOptions2.PreferCompoundAssignment,
+        new LocalizableResourceString(nameof(AnalyzersResources.Use_compound_assignment), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)))
 {
-    public CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer()
-        : base(IDEDiagnosticIds.UseCoalesceCompoundAssignmentDiagnosticId,
-               EnforceOnBuildValues.UseCoalesceCompoundAssignment,
-               CodeStyleOptions2.PreferCompoundAssignment,
-               new LocalizableResourceString(nameof(AnalyzersResources.Use_compound_assignment), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)))
-    {
-    }
-
     public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
         => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
@@ -97,7 +93,7 @@ private void AnalyzeCoalesceExpression(SyntaxNodeAnalysisContext context)
             coalesceExpression.OperatorToken.GetLocation(),
             option.Notification,
             context.Options,
-            additionalLocations: ImmutableArray.Create(coalesceExpression.GetLocation()),
+            additionalLocations: [coalesceExpression.GetLocation()],
             properties: null));
     }
 
@@ -170,7 +166,7 @@ private void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
             ifStatement.IfKeyword.GetLocation(),
             option.Notification,
             context.Options,
-            additionalLocations: ImmutableArray.Create(ifStatement.GetLocation()),
+            additionalLocations: [ifStatement.GetLocation()],
             properties: null));
     }
 

src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundAssignmentTests.cs

@@ -1570,4 +1570,39 @@ void M()
             }
             """);
     }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76633")]
+    public async Task TestFieldKeyword1()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                public class C
+                {
+                    int M
+                    {
+                        get
+                        {
+                            field [|=|] field + 10;
+                            return 0;
+                        }
+                    }
+                }
+                """,
+            FixedCode = """
+                public class C
+                {
+                    int M
+                    {
+                        get
+                        {
+                            field += 10;
+                            return 0;
+                        }
+                    }
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
 }

src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundCoalesceAssignmentTests.cs

@@ -999,4 +999,46 @@ public unsafe class C {
             }
             """, LanguageVersion.CSharp12);
     }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76633")]
+    public async Task TestFieldKeyword1()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                using System;
+                class C
+                {
+                    string Goo
+                    {
+                        get
+                        {
+                            [|if|] (field is null)
+                            {
+                                field = "";
+                            }
+
+                            return field;
+                        }
+                    }
+                }
+                """,
+            FixedCode = """
+                using System;
+                class C
+                {
+                    string Goo
+                    {
+                        get
+                        {
+                            field ??= "";
+            
+                            return field;
+                        }
+                    }
+                }
+                """,
+            LanguageVersion = LanguageVersion.Preview,
+        }.RunAsync();
+    }
 }

src/Analyzers/Core/Analyzers/UseCompoundAssignment/UseCompoundAssignmentUtilities.cs

@@ -48,16 +48,15 @@ private static bool IsSideEffectFreeRecurse(
         bool isTopLevel, CancellationToken cancellationToken)
     {
         if (expr == null)
-        {
             return false;
-        }
 
         // it basically has to be of the form "a.b.c", where all components are locals,
         // parameters or fields.  Basically, nothing that can cause arbitrary user code
         // execution when being evaluated by the compiler.
 
         if (syntaxFacts.IsThisExpression(expr) ||
-            syntaxFacts.IsBaseExpression(expr))
+            syntaxFacts.IsBaseExpression(expr) ||
+            syntaxFacts.IsFieldExpression(expr))
         {
             // Referencing this/base like  this.a.b.c causes no side effects itself.
             return true;

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs

@@ -97,6 +97,7 @@ public int Convert<TSyntaxKind>(TSyntaxKind kind) where TSyntaxKind : struct
     public int CollectionInitializerExpression => (int)SyntaxKind.CollectionInitializerExpression;
     public int ConditionalAccessExpression => (int)SyntaxKind.ConditionalAccessExpression;
     public int ConditionalExpression => (int)SyntaxKind.ConditionalExpression;
+    public int? FieldExpression => (int)SyntaxKind.FieldExpression;
     public int? ImplicitArrayCreationExpression => (int)SyntaxKind.ImplicitArrayCreationExpression;
     public int? ImplicitObjectCreationExpression => (int)SyntaxKind.ImplicitObjectCreationExpression;
     public int? IndexExpression => (int)SyntaxKind.IndexExpression;

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxFactsExtensions.cs

@@ -805,6 +805,9 @@ public static bool IsConditionalExpression(this ISyntaxFacts syntaxFacts, [NotNu
     public static bool IsConditionalAccessExpression(this ISyntaxFacts syntaxFacts, [NotNullWhen(true)] SyntaxNode? node)
         => node?.RawKind == syntaxFacts.SyntaxKinds.ConditionalAccessExpression;
 
+    public static bool IsFieldExpression(this ISyntaxFacts syntaxFacts, [NotNullWhen(true)] SyntaxNode? node)
+        => node?.RawKind == syntaxFacts.SyntaxKinds.FieldExpression;
+
     public static bool IsImplicitArrayCreationExpression(this ISyntaxFacts syntaxFacts, [NotNullWhen(true)] SyntaxNode? node)
         => node?.RawKind == syntaxFacts.SyntaxKinds.ImplicitArrayCreationExpression;
 

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs

@@ -139,6 +139,7 @@ internal interface ISyntaxKinds
     int CollectionInitializerExpression { get; }
     int ConditionalAccessExpression { get; }
     int ConditionalExpression { get; }
+    int? FieldExpression { get; }
     int? ImplicitArrayCreationExpression { get; }
     int? ImplicitObjectCreationExpression { get; }
     int? IndexExpression { get; }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb

@@ -99,6 +99,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageService
         Public ReadOnly Property CollectionInitializerExpression As Integer = SyntaxKind.CollectionInitializer Implements ISyntaxKinds.CollectionInitializerExpression
         Public ReadOnly Property ConditionalAccessExpression As Integer = SyntaxKind.ConditionalAccessExpression Implements ISyntaxKinds.ConditionalAccessExpression
         Public ReadOnly Property ConditionalExpression As Integer = SyntaxKind.TernaryConditionalExpression Implements ISyntaxKinds.ConditionalExpression
+        Public ReadOnly Property FieldExpression As Integer? Implements ISyntaxKinds.FieldExpression
         Public ReadOnly Property ImplicitArrayCreationExpression As Integer? Implements ISyntaxKinds.ImplicitArrayCreationExpression
         Public ReadOnly Property ImplicitObjectCreationExpression As Integer? Implements ISyntaxKinds.ImplicitObjectCreationExpression
         Public ReadOnly Property IndexExpression As Integer? Implements ISyntaxKinds.IndexExpression