Initial work to use new test library.

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionTest.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Composition;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
@@ -14,6 +15,7 @@
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.Editor.Implementation.Preview;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PickMembers;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Utilities;
@@ -114,32 +116,6 @@ protected override Task<ImmutableArray<Diagnostic>> GetDiagnosticsWorkerAsync(Te
         protected static Document GetDocument(TestWorkspace workspace)
             => workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
 
-        private class TestPickMembersService : IPickMembersService
-        {
-            private readonly ImmutableArray<string> _memberNames;
-            private readonly Action<ImmutableArray<PickMembersOption>> _optionsCallback;
-
-            public TestPickMembersService(
-                ImmutableArray<string> memberNames,
-                Action<ImmutableArray<PickMembersOption>> optionsCallback)
-            {
-                _memberNames = memberNames;
-                _optionsCallback = optionsCallback;
-            }
-
-            public PickMembersResult PickMembers(
-                string title, ImmutableArray<ISymbol> members,
-                ImmutableArray<PickMembersOption> options)
-            {
-                _optionsCallback?.Invoke(options);
-                return new PickMembersResult(
-                    _memberNames.IsDefault
-                        ? members
-                        : _memberNames.SelectAsArray(n => members.Single(m => m.Name == n)),
-                    options);
-            }
-        }
-
         internal static void EnableOptions(
             ImmutableArray<PickMembersOption> options,
             params string[] ids)
@@ -174,4 +150,39 @@ internal static void EnableOption(ImmutableArray<PickMembersOption> options, str
                 parameters.WithFixProviderData(pickMembersService));
         }
     }
+
+    [ExportWorkspaceService(typeof(IPickMembersService), ServiceLayer.Host), Shared, PartNotDiscoverable]
+    internal class TestPickMembersService : IPickMembersService
+    {
+        public ImmutableArray<string> MemberNames;
+        public Action<ImmutableArray<PickMembersOption>> OptionsCallback;
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public TestPickMembersService()
+        {
+        }
+
+#pragma warning disable RS0034 // Exported parts should be marked with 'ImportingConstructorAttribute'
+        public TestPickMembersService(
+            ImmutableArray<string> memberNames,
+            Action<ImmutableArray<PickMembersOption>> optionsCallback)
+        {
+            MemberNames = memberNames;
+            OptionsCallback = optionsCallback;
+        }
+#pragma warning restore RS0034 // Exported parts should be marked with 'ImportingConstructorAttribute'
+
+        public PickMembersResult PickMembers(
+            string title, ImmutableArray<ISymbol> members,
+            ImmutableArray<PickMembersOption> options)
+        {
+            OptionsCallback?.Invoke(options);
+            return new PickMembersResult(
+                MemberNames.IsDefault
+                    ? members
+                    : MemberNames.SelectAsArray(n => members.Single(m => m.Name == n)),
+                options);
+        }
+    }
 }

src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeAction.cs

@@ -80,8 +80,10 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                     await AddOperatorsAsync(methods, cancellationToken).ConfigureAwait(false);
                 }
 
+                var options = await _document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
                 var newTypeDeclaration = CodeGenerator.AddMemberDeclarations(
-                    _typeDeclaration, methods, _document.Project.Solution.Workspace);
+                    _typeDeclaration, methods, _document.Project.Solution.Workspace,
+                    new CodeGenerationOptions(options: options));
 
                 if (constructedTypeToImplement is object)
                 {

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

@@ -139,7 +139,7 @@ protected override TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode
                 if (method.IsConstructor())
                 {
                     return Cast<TDeclarationNode>(ConstructorGenerator.AddConstructorTo(
-                        typeDeclaration, method, Workspace, options, availableIndices));
+                        typeDeclaration, method, options, availableIndices));
                 }
 
                 if (method.IsDestructor())
@@ -150,13 +150,13 @@ protected override TDeclarationNode AddMethod<TDeclarationNode>(TDeclarationNode
                 if (method.MethodKind == MethodKind.Conversion)
                 {
                     return Cast<TDeclarationNode>(ConversionGenerator.AddConversionTo(
-                        typeDeclaration, method, Workspace, options, availableIndices));
+                        typeDeclaration, method, options, availableIndices));
                 }
 
                 if (method.MethodKind == MethodKind.UserDefinedOperator)
                 {
                     return Cast<TDeclarationNode>(OperatorGenerator.AddOperatorTo(
-                        typeDeclaration, method, Workspace, options, availableIndices));
+                        typeDeclaration, method, options, availableIndices));
                 }
 
                 return Cast<TDeclarationNode>(MethodGenerator.AddMethodTo(
@@ -229,12 +229,12 @@ protected override TDeclarationNode AddProperty<TDeclarationNode>(TDeclarationNo
             if (destination is TypeDeclarationSyntax)
             {
                 return Cast<TDeclarationNode>(PropertyGenerator.AddPropertyTo(
-                    Cast<TypeDeclarationSyntax>(destination), property, Workspace, options, availableIndices));
+                    Cast<TypeDeclarationSyntax>(destination), property, options, availableIndices));
             }
             else
             {
                 return Cast<TDeclarationNode>(PropertyGenerator.AddPropertyTo(
-                    Cast<CompilationUnitSyntax>(destination), property, Workspace, options, availableIndices));
+                    Cast<CompilationUnitSyntax>(destination), property, options, availableIndices));
             }
         }
 
@@ -587,17 +587,17 @@ public override SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenera
             if (method.IsConstructor())
             {
                 return ConstructorGenerator.GenerateConstructorDeclaration(
-                    method, Workspace, options, options.ParseOptions);
+                    method, options, options.ParseOptions);
             }
             else if (method.IsUserDefinedOperator())
             {
                 return OperatorGenerator.GenerateOperatorDeclaration(
-                    method, Workspace, options, options.ParseOptions);
+                    method, options, options.ParseOptions);
             }
             else if (method.IsConversion())
             {
                 return ConversionGenerator.GenerateConversionDeclaration(
-                    method, Workspace, options, options.ParseOptions);
+                    method, options, options.ParseOptions);
             }
             else if (method.IsLocalFunction())
             {
@@ -615,7 +615,7 @@ public override SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenera
             IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options)
         {
             return PropertyGenerator.GeneratePropertyOrIndexer(
-                property, destination, Workspace, options, options.ParseOptions);
+                property, destination, options, options.ParseOptions);
         }
 
         public override SyntaxNode CreateNamedTypeDeclaration(

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

@@ -24,13 +24,11 @@ private static MemberDeclarationSyntax LastConstructorOrField(SyntaxList<MemberD
         internal static TypeDeclarationSyntax AddConstructorTo(
             TypeDeclarationSyntax destination,
             IMethodSymbol constructor,
-            Workspace workspace,
             CodeGenerationOptions options,
             IList<bool> availableIndices)
         {
             var constructorDeclaration = GenerateConstructorDeclaration(
-                constructor, workspace, options,
-                destination?.SyntaxTree.Options ?? options.ParseOptions);
+                constructor, options, destination?.SyntaxTree.Options ?? options.ParseOptions);
 
             // Generate after the last constructor, or after the last field, or at the start of the
             // type.
@@ -42,7 +40,6 @@ private static MemberDeclarationSyntax LastConstructorOrField(SyntaxList<MemberD
 
         internal static ConstructorDeclarationSyntax GenerateConstructorDeclaration(
             IMethodSymbol constructor,
-            Workspace workspace,
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
@@ -65,20 +62,20 @@ private static MemberDeclarationSyntax LastConstructorOrField(SyntaxList<MemberD
                 body: hasNoBody ? null : GenerateBlock(constructor),
                 semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default);
 
-            declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions);
+            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
                 ConditionallyAddDocumentationCommentTo(declaration, constructor, options));
         }
 
         private static ConstructorDeclarationSyntax UseExpressionBodyIfDesired(
-            Workspace workspace, ConstructorDeclarationSyntax declaration, ParseOptions options)
+            CodeGenerationOptions options, ConstructorDeclarationSyntax declaration, ParseOptions parseOptions)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors).Value;
+                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors).Value;
                 if (declaration.Body.TryConvertToArrowExpressionBody(
-                        declaration.Kind(), options, expressionBodyPreference,
+                        declaration.Kind(), parseOptions, expressionBodyPreference,
                         out var expressionBody, out var semicolonToken))
                 {
                     return declaration.WithBody(null)

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

@@ -18,13 +18,11 @@ internal static class ConversionGenerator
         internal static TypeDeclarationSyntax AddConversionTo(
             TypeDeclarationSyntax destination,
             IMethodSymbol method,
-            Workspace workspace,
             CodeGenerationOptions options,
             IList<bool> availableIndices)
         {
             var methodDeclaration = GenerateConversionDeclaration(
-                method, workspace, options,
-                destination?.SyntaxTree.Options ?? options.ParseOptions);
+                method, options, destination?.SyntaxTree.Options ?? options.ParseOptions);
 
             var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastOperator);
 
@@ -33,18 +31,16 @@ internal static class ConversionGenerator
 
         internal static ConversionOperatorDeclarationSyntax GenerateConversionDeclaration(
             IMethodSymbol method,
-            Workspace workspace,
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
-            var declaration = GenerateConversionDeclarationWorker(method, workspace, options, parseOptions);
+            var declaration = GenerateConversionDeclarationWorker(method, options, parseOptions);
             return AddFormatterAndCodeGeneratorAnnotationsTo(AddAnnotationsTo(method,
                 ConditionallyAddDocumentationCommentTo(declaration, method, options)));
         }
 
         private static ConversionOperatorDeclarationSyntax GenerateConversionDeclarationWorker(
             IMethodSymbol method,
-            Workspace workspace,
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
@@ -70,20 +66,20 @@ internal static class ConversionGenerator
                 body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
                 semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
 
-            declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions);
+            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
 
             return declaration;
         }
 
         private static ConversionOperatorDeclarationSyntax UseExpressionBodyIfDesired(
-            Workspace workspace, ConversionOperatorDeclarationSyntax declaration, ParseOptions options)
+            CodeGenerationOptions options, ConversionOperatorDeclarationSyntax declaration, ParseOptions parseOptions)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
+                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
 
                 if (declaration.Body.TryConvertToArrowExpressionBody(
-                        declaration.Kind(), options, expressionBodyPreference,
+                        declaration.Kind(), parseOptions, expressionBodyPreference,
                         out var expressionBody, out var semicolonToken))
                 {
                     return declaration.WithBody(null)

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

@@ -19,13 +19,11 @@ internal static class OperatorGenerator
         internal static TypeDeclarationSyntax AddOperatorTo(
             TypeDeclarationSyntax destination,
             IMethodSymbol method,
-            Workspace workspace,
             CodeGenerationOptions options,
             IList<bool> availableIndices)
         {
             var methodDeclaration = GenerateOperatorDeclaration(
-                method, workspace, options,
-                destination?.SyntaxTree.Options ?? options.ParseOptions);
+                method, options, destination?.SyntaxTree.Options ?? options.ParseOptions);
 
             var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastOperator);
 
@@ -34,7 +32,6 @@ internal static class OperatorGenerator
 
         internal static OperatorDeclarationSyntax GenerateOperatorDeclaration(
             IMethodSymbol method,
-            Workspace workspace,
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
@@ -45,20 +42,20 @@ internal static class OperatorGenerator
             }
 
             var declaration = GenerateOperatorDeclarationWorker(method, options, parseOptions);
-            declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions);
+            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
 
             return AddAnnotationsTo(method,
                 ConditionallyAddDocumentationCommentTo(declaration, method, options));
         }
 
         private static OperatorDeclarationSyntax UseExpressionBodyIfDesired(
-            Workspace workspace, OperatorDeclarationSyntax declaration, ParseOptions options)
+            CodeGenerationOptions options, OperatorDeclarationSyntax declaration, ParseOptions parseOptions)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
+                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value;
                 if (declaration.Body.TryConvertToArrowExpressionBody(
-                        declaration.Kind(), options, expressionBodyPreference,
+                        declaration.Kind(), parseOptions, expressionBodyPreference,
                         out var expressionBody, out var semicolonToken))
                 {
                     return declaration.WithBody(null)
@@ -99,24 +96,24 @@ internal static class OperatorGenerator
             return operatorDecl;
         }
 
-        private static OperatorDeclarationSyntax UseExpressionBodyIfDesired(
-            CodeGenerationOptions options, OperatorDeclarationSyntax operatorDeclaration, ParseOptions parseOptions)
-        {
-            if (operatorDeclaration.ExpressionBody == null)
-            {
-                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods).Value;
-                if (operatorDeclaration.Body.TryConvertToArrowExpressionBody(
-                        operatorDeclaration.Kind(), parseOptions, expressionBodyPreference,
-                        out var expressionBody, out var semicolonToken))
-                {
-                    return operatorDeclaration.WithBody(null)
-                                              .WithExpressionBody(expressionBody)
-                                              .WithSemicolonToken(semicolonToken);
-                }
-            }
-
-            return operatorDeclaration;
-        }
+        //private static OperatorDeclarationSyntax UseExpressionBodyIfDesired(
+        //    CodeGenerationOptions options, OperatorDeclarationSyntax operatorDeclaration, ParseOptions parseOptions)
+        //{
+        //    if (operatorDeclaration.ExpressionBody == null)
+        //    {
+        //        var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods).Value;
+        //        if (operatorDeclaration.Body.TryConvertToArrowExpressionBody(
+        //                operatorDeclaration.Kind(), parseOptions, expressionBodyPreference,
+        //                out var expressionBody, out var semicolonToken))
+        //        {
+        //            return operatorDeclaration.WithBody(null)
+        //                                      .WithExpressionBody(expressionBody)
+        //                                      .WithSemicolonToken(semicolonToken);
+        //        }
+        //    }
+
+        //    return operatorDeclaration;
+        //}
 
         private static SyntaxTokenList GenerateModifiers()
         {

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

@@ -33,12 +33,11 @@ public static bool CanBeGenerated(IPropertySymbol property)
         internal static CompilationUnitSyntax AddPropertyTo(
             CompilationUnitSyntax destination,
             IPropertySymbol property,
-            Workspace workspace,
             CodeGenerationOptions options,
             IList<bool> availableIndices)
         {
             var declaration = GeneratePropertyOrIndexer(
-                property, CodeGenerationDestination.CompilationUnit, workspace, options,
+                property, CodeGenerationDestination.CompilationUnit, options,
                 destination?.SyntaxTree.Options ?? options.ParseOptions);
 
             var members = Insert(destination.Members, declaration, options,
@@ -49,11 +48,10 @@ public static bool CanBeGenerated(IPropertySymbol property)
         internal static TypeDeclarationSyntax AddPropertyTo(
             TypeDeclarationSyntax destination,
             IPropertySymbol property,
-            Workspace workspace,
             CodeGenerationOptions options,
             IList<bool> availableIndices)
         {
-            var declaration = GeneratePropertyOrIndexer(property, GetDestination(destination), workspace,
+            var declaration = GeneratePropertyOrIndexer(property, GetDestination(destination),
                 options, destination?.SyntaxTree.Options ?? options.ParseOptions);
 
             // Create a clone of the original type with the new method inserted. 
@@ -68,7 +66,6 @@ public static bool CanBeGenerated(IPropertySymbol property)
         public static MemberDeclarationSyntax GeneratePropertyOrIndexer(
             IPropertySymbol property,
             CodeGenerationDestination destination,
-            Workspace workspace,
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
@@ -79,8 +76,8 @@ public static bool CanBeGenerated(IPropertySymbol property)
             }
 
             var declaration = property.IsIndexer
-                ? GenerateIndexerDeclaration(property, destination, workspace, options, parseOptions)
-                : GeneratePropertyDeclaration(property, destination, workspace, options, parseOptions);
+                ? GenerateIndexerDeclaration(property, destination, options, parseOptions)
+                : GeneratePropertyDeclaration(property, destination, options, parseOptions);
 
             return ConditionallyAddDocumentationCommentTo(declaration, property, options);
         }
@@ -88,7 +85,6 @@ public static bool CanBeGenerated(IPropertySymbol property)
         private static MemberDeclarationSyntax GenerateIndexerDeclaration(
             IPropertySymbol property,
             CodeGenerationDestination destination,
-            Workspace workspace,
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
@@ -100,8 +96,8 @@ public static bool CanBeGenerated(IPropertySymbol property)
                     type: GenerateTypeSyntax(property),
                     explicitInterfaceSpecifier: explicitInterfaceSpecifier,
                     parameterList: ParameterGenerator.GenerateBracketedParameterList(property.Parameters, explicitInterfaceSpecifier != null, options),
-                    accessorList: GenerateAccessorList(property, destination, workspace, options, parseOptions));
-            declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions);
+                    accessorList: GenerateAccessorList(property, destination, options, parseOptions));
+            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
                 AddAnnotationsTo(property, declaration));
@@ -109,7 +105,7 @@ public static bool CanBeGenerated(IPropertySymbol property)
 
         private static MemberDeclarationSyntax GeneratePropertyDeclaration(
            IPropertySymbol property, CodeGenerationDestination destination,
-           Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions)
+           CodeGenerationOptions options, ParseOptions parseOptions)
         {
             var initializer = CodeGenerationPropertyInfo.GetInitializer(property) is ExpressionSyntax initializerNode
                 ? SyntaxFactory.EqualsValueClause(initializerNode)
@@ -117,7 +113,7 @@ public static bool CanBeGenerated(IPropertySymbol property)
 
             var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
 
-            var accessorList = GenerateAccessorList(property, destination, workspace, options, parseOptions);
+            var accessorList = GenerateAccessorList(property, destination, options, parseOptions);
 
             var propertyDeclaration = SyntaxFactory.PropertyDeclaration(
                 attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options),
@@ -129,8 +125,7 @@ public static bool CanBeGenerated(IPropertySymbol property)
                 expressionBody: null,
                 initializer: initializer);
 
-            propertyDeclaration = UseExpressionBodyIfDesired(
-                workspace, propertyDeclaration, parseOptions);
+            propertyDeclaration = UseExpressionBodyIfDesired(options, propertyDeclaration, parseOptions);
 
             return AddFormatterAndCodeGeneratorAnnotationsTo(
                 AddAnnotationsTo(property, propertyDeclaration));
@@ -177,15 +172,15 @@ private static TypeSyntax GenerateTypeSyntax(IPropertySymbol property)
         }
 
         private static PropertyDeclarationSyntax UseExpressionBodyIfDesired(
-            Workspace workspace, PropertyDeclarationSyntax declaration, ParseOptions options)
+            CodeGenerationOptions options, PropertyDeclarationSyntax declaration, ParseOptions parseOptions)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
+                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties).Value;
                 if (declaration.Initializer == null)
                 {
                     if (TryGetExpressionBody(
-                            declaration, options, expressionBodyPreference,
+                            declaration, parseOptions, expressionBodyPreference,
                             out var expressionBody, out var semicolonToken))
                     {
                         declaration = declaration.WithAccessorList(null)
@@ -199,13 +194,13 @@ private static TypeSyntax GenerateTypeSyntax(IPropertySymbol property)
         }
 
         private static IndexerDeclarationSyntax UseExpressionBodyIfDesired(
-            Workspace workspace, IndexerDeclarationSyntax declaration, ParseOptions options)
+            CodeGenerationOptions options, IndexerDeclarationSyntax declaration, ParseOptions parseOptions)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers).Value;
+                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers).Value;
                 if (TryGetExpressionBody(
-                        declaration, options, expressionBodyPreference,
+                        declaration, parseOptions, expressionBodyPreference,
                         out var expressionBody, out var semicolonToken))
                 {
                     declaration = declaration.WithAccessorList(null)
@@ -218,13 +213,13 @@ private static TypeSyntax GenerateTypeSyntax(IPropertySymbol property)
         }
 
         private static AccessorDeclarationSyntax UseExpressionBodyIfDesired(
-            Workspace workspace, AccessorDeclarationSyntax declaration, ParseOptions options)
+            CodeGenerationOptions options, AccessorDeclarationSyntax declaration, ParseOptions parseOptions)
         {
             if (declaration.ExpressionBody == null)
             {
-                var expressionBodyPreference = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors).Value;
+                var expressionBodyPreference = options.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors).Value;
                 if (declaration.Body.TryConvertToArrowExpressionBody(
-                        declaration.Kind(), options, expressionBodyPreference,
+                        declaration.Kind(), parseOptions, expressionBodyPreference,
                         out var expressionBody, out var semicolonToken))
                 {
                     declaration = declaration.WithBody(null)
@@ -255,13 +250,13 @@ private static TypeSyntax GenerateTypeSyntax(IPropertySymbol property)
 
         private static AccessorListSyntax GenerateAccessorList(
             IPropertySymbol property, CodeGenerationDestination destination,
-            Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions)
+            CodeGenerationOptions options, ParseOptions parseOptions)
         {
             var setAccessorKind = property.SetMethod?.IsInitOnly == true ? SyntaxKind.InitAccessorDeclaration : SyntaxKind.SetAccessorDeclaration;
             var accessors = new List<AccessorDeclarationSyntax>
             {
-                GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, workspace, options, parseOptions),
-                GenerateAccessorDeclaration(property, property.SetMethod, setAccessorKind, destination, workspace, options, parseOptions),
+                GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, options, parseOptions),
+                GenerateAccessorDeclaration(property, property.SetMethod, setAccessorKind, destination, options, parseOptions),
             };
 
             return accessors[0] == null && accessors[1] == null
@@ -274,14 +269,13 @@ private static TypeSyntax GenerateTypeSyntax(IPropertySymbol property)
             IMethodSymbol accessor,
             SyntaxKind kind,
             CodeGenerationDestination destination,
-            Workspace workspace,
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
             var hasBody = options.GenerateMethodBodies && HasAccessorBodies(property, destination, accessor);
             return accessor == null
                 ? null
-                : GenerateAccessorDeclaration(property, accessor, kind, hasBody, workspace, options, parseOptions);
+                : GenerateAccessorDeclaration(property, accessor, kind, hasBody, options, parseOptions);
         }
 
         private static AccessorDeclarationSyntax GenerateAccessorDeclaration(
@@ -289,7 +283,6 @@ private static TypeSyntax GenerateTypeSyntax(IPropertySymbol property)
             IMethodSymbol accessor,
             SyntaxKind kind,
             bool hasBody,
-            Workspace workspace,
             CodeGenerationOptions options,
             ParseOptions parseOptions)
         {
@@ -298,7 +291,7 @@ private static TypeSyntax GenerateTypeSyntax(IPropertySymbol property)
                                            .WithBody(hasBody ? GenerateBlock(accessor) : null)
                                            .WithSemicolonToken(hasBody ? default : SyntaxFactory.Token(SyntaxKind.SemicolonToken));
 
-            declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions);
+            declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
 
             return AddAnnotationsTo(accessor, declaration);
         }