Add support for generating accessors with expression bodies.

src/Workspaces/CSharp/Portable/CodeGeneration/ConversionGenerator.cs

@@ -79,7 +79,7 @@ internal static class ConversionGenerator
         {
             if (declaration.ExpressionBody == null)
             {
-                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods).Value;
+                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
                 if (preferExpressionBody)
                 {
                     var expressionBody = CodeGenerationHelpers.TryConvertToExpressionBody(declaration.Body);

src/Workspaces/CSharp/Portable/CodeGeneration/OperatorGenerator.cs

@@ -48,11 +48,12 @@ internal static class OperatorGenerator
                 ConditionallyAddDocumentationCommentTo(declaration, method, options));
         }
 
-        private static OperatorDeclarationSyntax UseExpressionBodyIfDesired(Workspace workspace, OperatorDeclarationSyntax declaration)
+        private static OperatorDeclarationSyntax UseExpressionBodyIfDesired(
+            Workspace workspace, OperatorDeclarationSyntax declaration)
         {
             if (declaration.ExpressionBody == null)
             {
-                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods).Value;
+                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
                 if (preferExpressionBody)
                 {
                     var expressionBody = CodeGenerationHelpers.TryConvertToExpressionBody(declaration.Body);

src/Workspaces/CSharp/Portable/CodeGeneration/PropertyGenerator.cs

@@ -95,7 +95,7 @@ public static bool CanBeGenerated(IPropertySymbol property)
                     type: property.Type.GenerateTypeSyntax(),
                     explicitInterfaceSpecifier: explicitInterfaceSpecifier,
                     parameterList: ParameterGenerator.GenerateBracketedParameterList(property.Parameters, explicitInterfaceSpecifier != null, options),
-                    accessorList: GenerateAccessorList(property, destination, options));
+                    accessorList: GenerateAccessorList(property, destination, workspace, options));
             declaration = UseExpressionBodyIfDesired(workspace, declaration);
 
             return AddCleanupAnnotationsTo(
@@ -114,7 +114,7 @@ public static bool CanBeGenerated(IPropertySymbol property)
 
             var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
 
-            var accessorList = GenerateAccessorList(property, destination, options);
+            var accessorList = GenerateAccessorList(property, destination, workspace, options);
 
             var propertyDeclaration = SyntaxFactory.PropertyDeclaration(
                 attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options),
@@ -133,6 +133,20 @@ public static bool CanBeGenerated(IPropertySymbol property)
                 AddAnnotationsTo(property, propertyDeclaration));
         }
 
+        private static ArrowExpressionClauseSyntax TryGetExpressionBody(AccessorListSyntax accessorList)
+        {
+            if (accessorList.Accessors.Count == 1)
+            {
+                var accessor = accessorList.Accessors[0];
+                if (accessor.IsKind(SyntaxKind.GetAccessorDeclaration))
+                {
+                    return TryGetExpressionBody(accessor);
+                }
+            }
+
+            return null;
+        }
+
         private static PropertyDeclarationSyntax UseExpressionBodyIfDesired(
             Workspace workspace, PropertyDeclarationSyntax declaration)
         {
@@ -157,32 +171,39 @@ public static bool CanBeGenerated(IPropertySymbol property)
             return declaration;
         }
 
-        private static ArrowExpressionClauseSyntax TryGetExpressionBody(AccessorListSyntax accessorList)
+        private static IndexerDeclarationSyntax UseExpressionBodyIfDesired(
+            Workspace workspace, IndexerDeclarationSyntax declaration)
         {
-            if (accessorList.Accessors.Count == 1)
+            if (declaration.ExpressionBody == null)
             {
-                var accessor = accessorList.Accessors[0];
-                if (accessor.IsKind(SyntaxKind.GetAccessorDeclaration))
+                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers).Value;
+                if (preferExpressionBody)
                 {
-                    return TryGetExpressionBody(accessor);
+                    var expressionBody = TryGetExpressionBody(declaration.AccessorList);
+                    if (expressionBody != null)
+                    {
+                        declaration = declaration.WithAccessorList(null)
+                                                 .WithExpressionBody(expressionBody)
+                                                 .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+                    }
                 }
             }
 
-            return null;
+            return declaration;
         }
 
-        private static IndexerDeclarationSyntax UseExpressionBodyIfDesired(
-            Workspace workspace, IndexerDeclarationSyntax declaration)
+        private static AccessorDeclarationSyntax UseExpressionBodyIfDesired(
+            Workspace workspace, AccessorDeclarationSyntax declaration)
         {
             if (declaration.ExpressionBody == null)
             {
-                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
+                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors).Value;
                 if (preferExpressionBody)
                 {
-                    var expressionBody = TryGetExpressionBody(declaration.AccessorList);
+                    var expressionBody = CodeGenerationHelpers.TryConvertToExpressionBody(declaration.Body);
                     if (expressionBody != null)
                     {
-                        declaration = declaration.WithAccessorList(null)
+                        declaration = declaration.WithBody(null)
                                                  .WithExpressionBody(expressionBody)
                                                  .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
                     }
@@ -202,12 +223,13 @@ private static ArrowExpressionClauseSyntax TryGetExpressionBody(AccessorDeclarat
         }
 
         private static AccessorListSyntax GenerateAccessorList(
-            IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options)
+            IPropertySymbol property, CodeGenerationDestination destination, 
+            Workspace workspace, CodeGenerationOptions options)
         {
             var accessors = new List<AccessorDeclarationSyntax>
             {
-                GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, options),
-                GenerateAccessorDeclaration(property, property.SetMethod, SyntaxKind.SetAccessorDeclaration, destination, options),
+                GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, workspace, options),
+                GenerateAccessorDeclaration(property, property.SetMethod, SyntaxKind.SetAccessorDeclaration, destination, workspace, options),
             };
 
             return accessors[0] == null && accessors[1] == null
@@ -220,12 +242,13 @@ private static ArrowExpressionClauseSyntax TryGetExpressionBody(AccessorDeclarat
             IMethodSymbol accessor,
             SyntaxKind kind,
             CodeGenerationDestination destination,
+            Workspace workspace,
             CodeGenerationOptions options)
         {
             var hasBody = options.GenerateMethodBodies && HasAccessorBodies(property, destination, accessor);
             return accessor == null
                 ? null
-                : GenerateAccessorDeclaration(property, accessor, kind, hasBody, options);
+                : GenerateAccessorDeclaration(property, accessor, kind, hasBody, workspace, options);
         }
 
         private static AccessorDeclarationSyntax GenerateAccessorDeclaration(
@@ -233,12 +256,17 @@ private static ArrowExpressionClauseSyntax TryGetExpressionBody(AccessorDeclarat
             IMethodSymbol accessor,
             SyntaxKind kind,
             bool hasBody,
+            Workspace workspace,
             CodeGenerationOptions options)
         {
-            return AddAnnotationsTo(accessor, SyntaxFactory.AccessorDeclaration(kind)
-                                .WithModifiers(GenerateAccessorModifiers(property, accessor, options))
-                                .WithBody(hasBody ? GenerateBlock(accessor) : null)
-                                .WithSemicolonToken(hasBody ? default(SyntaxToken) : SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
+            var declaration = SyntaxFactory.AccessorDeclaration(kind)
+                                           .WithModifiers(GenerateAccessorModifiers(property, accessor, options))
+                                           .WithBody(hasBody ? GenerateBlock(accessor) : null)
+                                           .WithSemicolonToken(hasBody ? default(SyntaxToken) : SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+
+            declaration = UseExpressionBodyIfDesired(workspace, declaration);
+
+            return AddAnnotationsTo(accessor, declaration);
         }
 
         private static BlockSyntax GenerateBlock(IMethodSymbol accessor)