Implement "Simplify property accessor" feature

src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems

@@ -74,6 +74,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)SimplifyInterpolation\CSharpSimplifyInterpolationDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SimplifyLinqExpression\CSharpSimplifyLinqExpressionDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SimplifyLinqExpression\CSharpSimplifyLinqTypeCheckAndCastDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)SimplifyPropertyAccessor\CSharpSimplifyPropertyAccessorDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SimplifyPropertyPattern\CSharpSimplifyPropertyPatternDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SimplifyPropertyPattern\SimplifyPropertyPatternHelpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConvertProgram\ConvertToProgramMainDiagnosticAnalyzer.cs" />

src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx

@@ -434,4 +434,10 @@
   <data name="Implement_with_Copilot" xml:space="preserve">
     <value>Implement with Copilot</value>
   </data>
+  <data name="Simplify_property_accessor" xml:space="preserve">
+    <value>Simplify property accessor</value>
+  </data>
+  <data name="Property_accessor_can_be_simplified" xml:space="preserve">
+    <value>Property accessor can be simplified</value>
+  </data>
 </root>

src/Analyzers/CSharp/Analyzers/CodeStyle/CSharpAnalyzerOptionsProvider.cs

@@ -71,6 +71,7 @@ internal CSharpSimplifierOptions GetSimplifierOptions()
     public CodeStyleOption2<bool> PreferPrimaryConstructors => GetOption(CSharpCodeStyleOptions.PreferPrimaryConstructors);
     public CodeStyleOption2<bool> PreferSystemThreadingLock => GetOption(CSharpCodeStyleOptions.PreferSystemThreadingLock);
     public CodeStyleOption2<bool> PreferUnboundGenericTypeInNameOf => GetOption(CSharpCodeStyleOptions.PreferUnboundGenericTypeInNameOf);
+    public CodeStyleOption2<bool> PreferSimplePropertyAccessors => GetOption(CSharpCodeStyleOptions.PreferSimplePropertyAccessors);
 
     // CodeGenerationOptions
 

src/Analyzers/CSharp/Analyzers/SimplifyPropertyAccessor/CSharpSimplifyPropertyAccessorDiagnosticAnalyzer.cs

@@ -0,0 +1,119 @@
+// 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.Linq;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Microsoft.CodeAnalysis.CSharp.SimplifyPropertyAccessor;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+internal sealed class CSharpSimplifyPropertyAccessorDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+{
+    public CSharpSimplifyPropertyAccessorDiagnosticAnalyzer()
+        : base(IDEDiagnosticIds.SimplifyPropertyAccessorDiagnosticId,
+               EnforceOnBuildValues.SimplifyPropertyAccessor,
+               CSharpCodeStyleOptions.PreferSimplePropertyAccessors,
+               new LocalizableResourceString(nameof(CSharpAnalyzersResources.Simplify_property_accessor), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)),
+               new LocalizableResourceString(nameof(CSharpAnalyzersResources.Property_accessor_can_be_simplified), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)))
+    {
+    }
+
+    public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+        => DiagnosticAnalyzerCategory.SyntaxTreeWithoutSemanticsAnalysis;
+
+    protected override void InitializeWorker(AnalysisContext context)
+        => context.RegisterSyntaxNodeAction(AnalyzePropertyDeclaration, SyntaxKind.PropertyDeclaration);
+
+    private void AnalyzePropertyDeclaration(SyntaxNodeAnalysisContext context)
+    {
+        var option = context.GetCSharpAnalyzerOptions().PreferSimplePropertyAccessors;
+        if (!option.Value || ShouldSkipAnalysis(context, option.Notification))
+            return;
+
+        var propertyDeclaration = (PropertyDeclarationSyntax)context.Node;
+
+        if (propertyDeclaration.AccessorList is not { } accessorList ||
+            accessorList.GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error))
+        {
+            return;
+        }
+
+        foreach (var accessor in accessorList.Accessors)
+        {
+            // get { return field; }
+            // get => field;
+            if (accessor is (SyntaxKind.GetAccessorDeclaration) { Body.Statements: [ReturnStatementSyntax { Expression.RawKind: (int)SyntaxKind.FieldExpression }] }
+                         or (SyntaxKind.GetAccessorDeclaration) { ExpressionBody.Expression.RawKind: (int)SyntaxKind.FieldExpression })
+            {
+                ReportIfValid(accessor);
+            }
+
+            // set/init { field = value; }
+            if (accessor is (SyntaxKind.SetAccessorDeclaration or SyntaxKind.InitAccessorDeclaration) { Body.Statements: [ExpressionStatementSyntax { Expression: var innerBlockBodyExpression }] } &&
+                IsFieldValueAssignmentExpression(innerBlockBodyExpression))
+            {
+                ReportIfValid(accessor);
+            }
+
+            // set/init => field = value;
+            if (accessor is (SyntaxKind.SetAccessorDeclaration or SyntaxKind.InitAccessorDeclaration) { ExpressionBody.Expression: var innerExpressionBodyExpression } &&
+                IsFieldValueAssignmentExpression(innerExpressionBodyExpression))
+            {
+                ReportIfValid(accessor);
+            }
+        }
+
+        // One can argue that these are semantic-level checks and they would be correct.
+        // However it is very simple to perform them on our own to not fall
+        // from the quick and efficient syntax-only analyzer path
+        static bool IsValidAccessorList(AccessorListSyntax accessorList)
+        {
+            var accessors = accessorList.Accessors;
+            if (accessors.Count > 2)
+                return false;
+
+            if (accessors is [var accessor1, var accessor2] &&
+                accessor1.RawKind == accessor2.RawKind)
+            {
+                return false;
+            }
+
+            return !accessorList.GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error);
+        }
+
+        static bool IsFieldValueAssignmentExpression(ExpressionSyntax expression)
+        {
+            return expression is AssignmentExpressionSyntax(SyntaxKind.SimpleAssignmentExpression)
+            {
+                Left.RawKind: (int)SyntaxKind.FieldExpression,
+                Right: IdentifierNameSyntax { Identifier.ValueText: "value" }
+            };
+        }
+
+        void ReportIfValid(AccessorDeclarationSyntax accessorDeclaration)
+        {
+            // If we are analyzing an accessor of a partial property and all other accessors have no bodies
+            // then if we simplify our current accessor the property will no longer be a valid
+            // implementation part. Thus we block that case
+            if (accessorDeclaration is { Parent: AccessorListSyntax { Parent: BasePropertyDeclarationSyntax containingPropertyDeclaration } containingAccessorList } &&
+                containingPropertyDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword) &&
+                containingAccessorList.Accessors.All(a => ReferenceEquals(a, accessorDeclaration) || a is { Body: null, ExpressionBody: null }))
+            {
+                return;
+            }
+
+            context.ReportDiagnostic(DiagnosticHelper.Create(
+                Descriptor,
+                accessorDeclaration.GetLocation(),
+                option.Notification,
+                context.Options,
+                additionalLocations: null,
+                properties: null));
+        }
+    }
+}