diff --git a/ChangeLog.md b/ChangeLog.md
index 5e03a0c675..d47d361789 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add analyzer "Put expression body on its own line" [RCS0062](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS0062) ([PR](https://github.com/dotnet/roslynator/pull/1593) by @cbersch)
+  - Affects analyzer [RCS1016](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1016)
+  - Affects refacoring [RR0169](https://josefpihrt.github.io/docs/roslynator/refactorings/RR0169)
+
 ## [4.12.11] - 2025-01-28
 
 ### Added
diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index 4e010d95f7..5a949271f0 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -1629,6 +1629,23 @@ public class C
       </Sample>
     </Samples>
   </Analyzer>
+  <Analyzer>
+    <Id>RCS0062</Id>
+    <Identifier>PutExpressionBodyOnItsOwnLine</Identifier>
+    <Title>Put expression body on its own line</Title>
+    <DefaultSeverity>Info</DefaultSeverity>
+    <IsEnabledByDefault>false</IsEnabledByDefault>
+    <Samples>
+      <Sample>
+        <Before><![CDATA[object Foo() => null;]]></Before>
+        <After><![CDATA[object Foo()
+    => null;]]></After>
+      </Sample>
+    </Samples>
+    <ConfigOptions>
+      <Option Key="arrow_token_new_line" IsRequired="false" />
+    </ConfigOptions>
+  </Analyzer>
   <Analyzer>
     <Id>RCS1001</Id>
     <Identifier>AddBracesWhenExpressionSpansOverMultipleLines</Identifier>
@@ -1978,6 +1995,7 @@ foreach (var item in items)
       <Option Key="body_style" IsRequired="true" />
       <Option Key="use_block_body_when_declaration_spans_over_multiple_lines" IsRequired="true" />
       <Option Key="use_block_body_when_expression_spans_over_multiple_lines" IsRequired="true" />
+      <Option Key="arrow_token_new_line" IsRequired="false" />
     </ConfigOptions>
     <Options>
       <Option Identifier="ConvertExpressionBodyToBlockBodyWhenExpressionIsMultiLine">
diff --git a/src/Common/CSharp/Analysis/ConvertExpressionBodyAnalysis.cs b/src/Common/CSharp/Analysis/ConvertExpressionBodyAnalysis.cs
new file mode 100644
index 0000000000..933a419c3f
--- /dev/null
+++ b/src/Common/CSharp/Analysis/ConvertExpressionBodyAnalysis.cs
@@ -0,0 +1,24 @@
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Roslynator.CSharp.Analysis;
+
+internal static class ConvertExpressionBodyAnalysis
+{
+    public static bool AllowPutExpressionBodyOnItsOwnLine(SyntaxKind syntaxKind)
+    {
+        // allow putting expression on new line for all method-like declarations, except for accessors.
+        switch (syntaxKind)
+        {
+            case SyntaxKind.MethodDeclaration:
+            case SyntaxKind.ConstructorDeclaration:
+            case SyntaxKind.DestructorDeclaration:
+            case SyntaxKind.PropertyDeclaration:
+            case SyntaxKind.IndexerDeclaration:
+            case SyntaxKind.OperatorDeclaration:
+            case SyntaxKind.ConversionOperatorDeclaration:
+                return true;
+            default:
+                return false;
+        }
+    }
+}
diff --git a/src/Common/DiagnosticIdentifiers.Generated.cs b/src/Common/DiagnosticIdentifiers.Generated.cs
index 7cb40c987c..2b9f9c7359 100644
--- a/src/Common/DiagnosticIdentifiers.Generated.cs
+++ b/src/Common/DiagnosticIdentifiers.Generated.cs
@@ -61,6 +61,7 @@ public static partial class DiagnosticIdentifiers
         public const string PlaceNewLineAfterOrBeforeNullConditionalOperator = "RCS0059";
         public const string BlankLineAfterFileScopedNamespaceDeclaration = "RCS0060";
         public const string BlankLineBetweenSwitchSections = "RCS0061";
+        public const string PutExpressionBodyOnItsOwnLine = "RCS0062";
         public const string AddBracesWhenExpressionSpansOverMultipleLines = "RCS1001";
         public const string RemoveBraces = "RCS1002";
         public const string AddBracesToIfElseWhenExpressionSpansOverMultipleLines = "RCS1003";
diff --git a/src/Common/DiagnosticRules.Generated.cs b/src/Common/DiagnosticRules.Generated.cs
index 2768f9adc0..73c275e1b9 100644
--- a/src/Common/DiagnosticRules.Generated.cs
+++ b/src/Common/DiagnosticRules.Generated.cs
@@ -645,6 +645,18 @@ public static partial class DiagnosticRules
             helpLinkUri:        DiagnosticIdentifiers.BlankLineBetweenSwitchSections, 
             customTags:         []);
 
+        /// <summary>RCS0062</summary>
+        public static readonly DiagnosticDescriptor PutExpressionBodyOnItsOwnLine = DiagnosticDescriptorFactory.Create(
+            id:                 DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine, 
+            title:              "Put expression body on its own line", 
+            messageFormat:      "Put expression body on its own line", 
+            category:           DiagnosticCategories.Roslynator, 
+            defaultSeverity:    DiagnosticSeverity.Info, 
+            isEnabledByDefault: false, 
+            description:        null, 
+            helpLinkUri:        DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine, 
+            customTags:         []);
+
         /// <summary>RCS1001</summary>
         public static readonly DiagnosticDescriptor AddBracesWhenExpressionSpansOverMultipleLines = DiagnosticDescriptorFactory.Create(
             id:                 DiagnosticIdentifiers.AddBracesWhenExpressionSpansOverMultipleLines, 
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/SyntaxTokenCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/SyntaxTokenCodeFixProvider.cs
index 49de20b3f8..9bef9cf3a0 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/SyntaxTokenCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/SyntaxTokenCodeFixProvider.cs
@@ -24,7 +24,8 @@ public override ImmutableArray<string> FixableDiagnosticIds
                 DiagnosticIdentifiers.PlaceNewLineAfterOrBeforeArrowToken,
                 DiagnosticIdentifiers.PlaceNewLineAfterOrBeforeEqualsToken,
                 DiagnosticIdentifiers.PutAttributeListOnItsOwnLine,
-                DiagnosticIdentifiers.AddOrRemoveNewLineBeforeWhileInDoStatement);
+                DiagnosticIdentifiers.AddOrRemoveNewLineBeforeWhileInDoStatement,
+                DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine);
         }
     }
 
@@ -60,6 +61,11 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 await CodeActionFactory.RegisterCodeActionForNewLineAsync(context).ConfigureAwait(false);
                 break;
             }
+            case DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine:
+            {
+                await CodeActionFactory.RegisterCodeActionForNewLineAsync(context, increaseIndentation: true).ConfigureAwait(false);
+                break;
+            }
         }
     }
 }
diff --git a/src/Formatting.Analyzers/CSharp/PutExpressionBodyOnItsOwnLineAnalyzer.cs b/src/Formatting.Analyzers/CSharp/PutExpressionBodyOnItsOwnLineAnalyzer.cs
new file mode 100644
index 0000000000..1ed6c9a7ec
--- /dev/null
+++ b/src/Formatting.Analyzers/CSharp/PutExpressionBodyOnItsOwnLineAnalyzer.cs
@@ -0,0 +1,74 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Roslynator.CSharp;
+using Roslynator.CSharp.Analysis;
+using Roslynator.CSharp.CodeStyle;
+
+namespace Roslynator.Formatting.CSharp;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class PutExpressionBodyOnItsOwnLineAnalyzer : BaseDiagnosticAnalyzer
+{
+    private static ImmutableArray<DiagnosticDescriptor> _supportedDiagnostics;
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+    {
+        get
+        {
+            if (_supportedDiagnostics.IsDefault)
+                Immutable.InterlockedInitialize(ref _supportedDiagnostics, DiagnosticRules.PutExpressionBodyOnItsOwnLine);
+
+            return _supportedDiagnostics;
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+
+        context.RegisterSyntaxNodeAction(f => AnalyzeArrowExpressionClause(f), SyntaxKind.ArrowExpressionClause);
+    }
+
+    private static void AnalyzeArrowExpressionClause(SyntaxNodeAnalysisContext context)
+    {
+        var arrowExpressionClause = (ArrowExpressionClauseSyntax)context.Node;
+
+        if (ConvertExpressionBodyAnalysis.AllowPutExpressionBodyOnItsOwnLine(arrowExpressionClause.Parent.Kind()))
+        {
+            AnalyzeArrowExpressionClause(arrowExpressionClause.ArrowToken, context);
+        }
+    }
+
+    private static void AnalyzeArrowExpressionClause(SyntaxToken arrowToken, SyntaxNodeAnalysisContext context)
+    {
+        NewLinePosition newLinePosition = context.GetArrowTokenNewLinePosition();
+
+        SyntaxToken first;
+        SyntaxToken second;
+        if (newLinePosition == NewLinePosition.After)
+        {
+            first = arrowToken;
+            second = arrowToken.GetNextToken();
+        }
+        else
+        {
+            first = arrowToken.GetPreviousToken();
+            second = arrowToken;
+        }
+
+        TriviaBlock block = TriviaBlock.FromBetween(first, second);
+
+        if (block.Kind == TriviaBlockKind.NoNewLine)
+        {
+            DiagnosticHelpers.ReportDiagnostic(
+                context,
+                DiagnosticRules.PutExpressionBodyOnItsOwnLine,
+                block.GetLocation());
+        }
+    }
+}
diff --git a/src/Refactorings.xml b/src/Refactorings.xml
index 0b530882be..0b6d9badb5 100644
--- a/src/Refactorings.xml
+++ b/src/Refactorings.xml
@@ -1606,6 +1606,9 @@ i--;]]></After>
       <Syntax>operator</Syntax>
     </Syntaxes>
     <Span>body or accessor list</Span>
+    <ConfigOptions>
+      <Option Key="arrow_token_new_line" IsRequired="false" />
+    </ConfigOptions>
   </Refactoring>
   <Refactoring Id="RR0170" Identifier="UseLambdaInsteadOfAnonymousMethod" Title="Use lambda instead of anonymous method">
     <OptionKey>use_lambda_instead_of_anonymous_method</OptionKey>
diff --git a/src/Tests/Analyzers.Tests/RCS1016UseExpressionBodyTests.cs b/src/Tests/Analyzers.Tests/RCS1016UseExpressionBodyTests.cs
index 74d2071d90..186c7f64b6 100644
--- a/src/Tests/Analyzers.Tests/RCS1016UseExpressionBodyTests.cs
+++ b/src/Tests/Analyzers.Tests/RCS1016UseExpressionBodyTests.cs
@@ -12,6 +12,11 @@ public class RCS1016UseExpressionBodyTests : AbstractCSharpDiagnosticVerifier<Us
 {
     public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.UseBlockBodyOrExpressionBody;
 
+    public override CSharpTestOptions Options
+    {
+        get { return base.Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression); }
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
     public async Task Test_Constructor()
     {
@@ -32,7 +37,59 @@ class C
 
     void M() { }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
+    public async Task Test_Constructor_BreakBeforeArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    public C()
+    [|{
+        M();
+    }|]
+
+    void M() { }
+}
+", @"
+class C
+{
+    public C()
+        => M();
+
+    void M() { }
+}
+",
+        options: Options.EnableDiagnostic(DiagnosticRules.PutExpressionBodyOnItsOwnLine)
+            .AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
+    public async Task Test_Constructor_BreakAfterArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    public C()
+    [|{
+        M();
+    }|]
+
+    void M() { }
+}
+", @"
+class C
+{
+    public C() =>
+        M();
+
+    void M() { }
+}
+",
+            options: Options.EnableDiagnostic(DiagnosticRules.PutExpressionBodyOnItsOwnLine)
+                .AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_After));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -55,7 +112,7 @@ class C
 
     void M() { }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -74,7 +131,7 @@ class C
 {
     string M() => null;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -97,7 +154,7 @@ string M(object x, object y) => M(
         x,
         y);
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -122,7 +179,7 @@ string M(object x, object y, object z) => M(
             y,
                 z);
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -141,7 +198,7 @@ class C
 {
     void M() => M();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -166,7 +223,7 @@ void M()
         string LF() => null;
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -199,7 +256,7 @@ string LF() => M(
             y);
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -224,7 +281,7 @@ void M()
         void LF() => M();
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -243,7 +300,7 @@ class C
 {
     string P => null;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -273,7 +330,7 @@ class C
 
     string M(string x, string y) => null;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -314,7 +371,7 @@ public string P
 
     string M(string x, string y) => null;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -355,7 +412,7 @@ public string P
 
     string M(string x, string y) => null;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression).AddAllowedCompilerDiagnosticId("CS0518"));
+", options: Options.AddAllowedCompilerDiagnosticId("CS0518"));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -374,7 +431,7 @@ class C
 {
     string this[int index] => null;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -402,7 +459,7 @@ string this[int index]
         set => _f = value;
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -421,7 +478,7 @@ class C
 {
     public static C operator !(C value) => value;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -440,7 +497,7 @@ class C
 {
     public static explicit operator C(string value) => new C();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -463,7 +520,7 @@ class C
 
     void M() { }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -482,7 +539,7 @@ class C
 {
     ~C() => throw new System.NotImplementedException();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -501,7 +558,7 @@ class C
 {
     string M() => throw new System.NotImplementedException();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -520,7 +577,7 @@ class C
 {
     void M() => throw new System.NotImplementedException();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -545,7 +602,7 @@ void M()
         string LF() => throw new System.NotImplementedException();
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -570,7 +627,7 @@ void M()
         void LF() => throw new System.NotImplementedException();
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -589,7 +646,7 @@ class C
 {
     string P => throw new System.NotImplementedException();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -617,7 +674,7 @@ public string P
         set => throw new System.NotImplementedException();
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -636,7 +693,7 @@ class C
 {
     string this[int index] => throw new System.NotImplementedException();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -664,7 +721,7 @@ string this[int index]
         set => throw new System.NotImplementedException();
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -683,7 +740,7 @@ class C
 {
     public static C operator !(C value) => throw new System.NotImplementedException();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -702,7 +759,7 @@ class C
 {
     public static explicit operator C(string value) => throw new System.NotImplementedException();
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -717,7 +774,7 @@ string M()
         return null;
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -731,7 +788,7 @@ void M()
         void LF() { }
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -744,7 +801,7 @@ void M()
     {
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -759,7 +816,7 @@ void M()
         M();
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -794,7 +851,7 @@ string P
 
     string M() => null;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -830,7 +887,7 @@ string P
         }
     }
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -852,7 +909,7 @@ string this[int index]
 
     string M() => null;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
@@ -901,7 +958,7 @@ public string P2
 
     string _f;
 }
-", options: Options.AddConfigOption(ConfigOptionKeys.BodyStyle, ConfigOptionValues.BodyStyle_Expression));
+", options: Options);
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseBlockBodyOrExpressionBody)]
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS0062PutExpressionBodyOnItsOwnLineTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS0062PutExpressionBodyOnItsOwnLineTests.cs
new file mode 100644
index 0000000000..c1b261ed4f
--- /dev/null
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS0062PutExpressionBodyOnItsOwnLineTests.cs
@@ -0,0 +1,276 @@
+// Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Roslynator.Formatting.CodeFixes.CSharp;
+using Roslynator.Testing.CSharp;
+using Xunit;
+
+namespace Roslynator.Formatting.CSharp.Tests;
+
+public class RCS0062PutExpressionBodyOnItsOwnLineTests : AbstractCSharpDiagnosticVerifier<PutExpressionBodyOnItsOwnLineAnalyzer, SyntaxTokenCodeFixProvider>
+{
+    public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.PutExpressionBodyOnItsOwnLine;
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_Constructor_BreakAfterArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    public C() =>[| |]M();
+
+    void M() { }
+}
+", @"
+class C
+{
+    public C() =>
+        M();
+
+    void M() { }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_After));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_Constructor_BreakBeforeArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    public C()[| |]=> M();
+
+    void M() { }
+}
+", @"
+class C
+{
+    public C()
+        => M();
+
+    void M() { }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_Destructor_BreakAfterArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    ~C() =>[| |]M();
+
+    void M() { }
+}
+", @"
+class C
+{
+    ~C() =>
+        M();
+
+    void M() { }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_After));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_Destructor_BreakBeforeArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    ~C()[| |]=> M();
+
+    void M() { }
+}
+", @"
+class C
+{
+    ~C()
+        => M();
+
+    void M() { }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_Method_BreakAfterArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    string M() =>[| |]null;
+}
+", @"
+class C
+{
+    string M() =>
+        null;
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_After));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_Method_BreakBeforeArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    string M()[| |]=> null;
+}
+", @"
+class C
+{
+    string M()
+        => null;
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_Operator_BreakAfterArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    public static C operator !(C value) =>[| |]value;
+}
+", @"
+class C
+{
+    public static C operator !(C value) =>
+        value;
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_After));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_Operator_BreakBeforeArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    public static C operator !(C value)[| |]=> value;
+}
+", @"
+class C
+{
+    public static C operator !(C value)
+        => value;
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_ConversionOperator_BreakAfterArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    public static explicit operator C(string value) =>[| |]new C();
+}
+", @"
+class C
+{
+    public static explicit operator C(string value) =>
+        new C();
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_After));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_ConversionOperator_BreakBeforeArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    public static explicit operator C(string value)[| |]=> new C();
+}
+", @"
+class C
+{
+    public static explicit operator C(string value)
+        => new C();
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_PropertyWithoutAccessor_BreakAfterArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    string P =>[| |]null;
+}
+", @"
+class C
+{
+    string P =>
+        null;
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_After));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task Test_PropertyWithoutAccessor_BreakBeforeArrow()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    string P[| |]=> null;
+}
+", @"
+class C
+{
+    string P
+        => null;
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task TestNoDiagnostic_LocalFunction()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class C
+{
+    void M()
+    {
+        string LF() => null;
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task TestNoDiagnostic_PropertyWithGetter()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class C
+{
+    string P
+    {
+        get => null;
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.PutExpressionBodyOnItsOwnLine)]
+    public async Task TestNoDiagnostic_IndexerWithGetter()
+    {
+        await VerifyNoDiagnosticAsync(@"
+class C
+{
+    string this[int index]
+    {
+        get => null;
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+}
diff --git a/src/Tests/Refactorings.Tests/RR0169ConvertBlockBodyToExpressionBodyTests.cs b/src/Tests/Refactorings.Tests/RR0169ConvertBlockBodyToExpressionBodyTests.cs
index 1801375586..7bbadb17b5 100644
--- a/src/Tests/Refactorings.Tests/RR0169ConvertBlockBodyToExpressionBodyTests.cs
+++ b/src/Tests/Refactorings.Tests/RR0169ConvertBlockBodyToExpressionBodyTests.cs
@@ -18,7 +18,7 @@ class C
 {
     public C()
     [|{
-[||]       M();
+[||]        M();
     }|]
 
     void M() { }
@@ -33,6 +33,60 @@ void M() { }
 ", equivalenceKey: EquivalenceKey.Create(RefactoringId));
     }
 
+    [Fact, Trait(Traits.Refactoring, RefactoringIdentifiers.ConvertBlockBodyToExpressionBody)]
+    public async Task Test_Constructor_BreakBeforeArrow()
+    {
+        await VerifyRefactoringAsync(@"
+class C
+{
+    public C()
+    [|{
+[||]        M();
+    }|]
+
+    void M() { }
+}
+", @"
+class C
+{
+    public C()
+        => M();
+
+    void M() { }
+}
+",
+        equivalenceKey: EquivalenceKey.Create(RefactoringId),
+        options: Options.EnableDiagnostic(DiagnosticRules.PutExpressionBodyOnItsOwnLine)
+            .AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_Before));
+    }
+
+    [Fact, Trait(Traits.Refactoring, RefactoringIdentifiers.ConvertBlockBodyToExpressionBody)]
+    public async Task Test_Constructor_BreakAfterArrow()
+    {
+        await VerifyRefactoringAsync(@"
+class C
+{
+    public C()
+    [|{
+[||]        M();
+    }|]
+
+    void M() { }
+}
+", @"
+class C
+{
+    public C() =>
+        M();
+
+    void M() { }
+}
+",
+        equivalenceKey: EquivalenceKey.Create(RefactoringId),
+        options: Options.EnableDiagnostic(DiagnosticRules.PutExpressionBodyOnItsOwnLine)
+            .AddConfigOption(ConfigOptionKeys.ArrowTokenNewLine, ConfigOptionValues.ArrowTokenNewLine_After));
+    }
+
     [Fact, Trait(Traits.Refactoring, RefactoringIdentifiers.ConvertBlockBodyToExpressionBody)]
     public async Task Test_Destructor()
     {
diff --git a/src/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
index 4af6961de1..52d38e81db 100644
--- a/src/VisualStudioCode/package/src/configurationFiles.generated.ts
+++ b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
@@ -42,7 +42,7 @@ roslynator_analyzers.enabled_by_default = true|false
 # Applicable to: rcs1014
 
 #roslynator_arrow_token_new_line = after|before
-# Applicable to: rcs0032
+# Applicable to: rcs0032, rcs0062, rcs1016
 
 #roslynator_binary_operator_new_line = after|before
 # Applicable to: rcs0027
@@ -309,6 +309,10 @@ roslynator_analyzers.enabled_by_default = true|false
 #dotnet_diagnostic.rcs0061.severity = none
 # Options: roslynator_blank_line_between_switch_sections
 
+# Put expression body on its own line
+#dotnet_diagnostic.rcs0062.severity = none
+# Options: roslynator_arrow_token_new_line
+
 # Add braces (when expression spans over multiple lines)
 #dotnet_diagnostic.rcs1001.severity = suggestion
 
@@ -342,7 +346,7 @@ roslynator_analyzers.enabled_by_default = true|false
 
 # Use block body or expression body
 #dotnet_diagnostic.rcs1016.severity = none
-# Options: roslynator_body_style, roslynator_use_block_body_when_declaration_spans_over_multiple_lines, roslynator_use_block_body_when_expression_spans_over_multiple_lines
+# Options: roslynator_arrow_token_new_line, roslynator_body_style, roslynator_use_block_body_when_declaration_spans_over_multiple_lines, roslynator_use_block_body_when_expression_spans_over_multiple_lines
 
 # Add/remove accessibility modifiers
 #dotnet_diagnostic.rcs1018.severity = none
diff --git a/src/Workspaces.Common/CSharp/Refactorings/ConvertBlockBodyToExpressionBodyRefactoring.cs b/src/Workspaces.Common/CSharp/Refactorings/ConvertBlockBodyToExpressionBodyRefactoring.cs
index 1f96f8c38f..035713ca4b 100644
--- a/src/Workspaces.Common/CSharp/Refactorings/ConvertBlockBodyToExpressionBodyRefactoring.cs
+++ b/src/Workspaces.Common/CSharp/Refactorings/ConvertBlockBodyToExpressionBodyRefactoring.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
 using Roslynator.CSharp.Analysis;
+using Roslynator.CSharp.CodeStyle;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 
 namespace Roslynator.CSharp.Refactorings;
@@ -165,8 +166,9 @@ public static Task<Document> RefactorAsync(
                     if (CanRefactor(member))
                     {
                         AnalyzerConfigOptions configOptions = document.GetConfigOptions(selectedMembers.Parent.SyntaxTree);
+                        NewLinePosition newLinePosition = GetNewLinePosition(document, member, configOptions, cancellationToken);
 
-                        var newMember = (MemberDeclarationSyntax)Refactor(member, configOptions);
+                        var newMember = (MemberDeclarationSyntax)Refactor(member, configOptions, newLinePosition);
 
                         return newMember
                             .WithTrailingTrivia(member.GetTrailingTrivia())
@@ -179,19 +181,43 @@ public static Task<Document> RefactorAsync(
         return document.ReplaceMembersAsync(SyntaxInfo.MemberDeclarationListInfo(selectedMembers.Parent), newMembers, cancellationToken);
     }
 
-    public static Task<Document> RefactorAsync(
+    public static async Task<Document> RefactorAsync(
         Document document,
         SyntaxNode node,
         CancellationToken cancellationToken = default)
     {
         AnalyzerConfigOptions configOptions = document.GetConfigOptions(node.SyntaxTree);
+        NewLinePosition newLinePosition = GetNewLinePosition(document, node, configOptions, cancellationToken);
+
+        SyntaxNode newNode = Refactor(node, configOptions, newLinePosition).WithFormatterAnnotation();
+
+        if (newLinePosition == NewLinePosition.After)
+        {
+            SyntaxToken arrowToken = CSharpUtility.GetExpressionBody(newNode).ArrowToken;
+            var annotation = new SyntaxAnnotation();
+            newNode = newNode.ReplaceToken(arrowToken, arrowToken.WithAdditionalAnnotations(annotation));
+            document = await document.ReplaceNodeAsync(node, newNode, cancellationToken).ConfigureAwait(false);
+            SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            arrowToken = root.GetAnnotatedTokens(annotation).Single();
+            var textChange = new TextChange(TextSpan.FromBounds(arrowToken.GetPreviousToken().Span.End, arrowToken.SpanStart), " ");
+            return await document.WithTextChangeAsync(textChange, cancellationToken).ConfigureAwait(false);
+        }
+
+        return await document.ReplaceNodeAsync(node, newNode, cancellationToken).ConfigureAwait(false);
+    }
 
-        SyntaxNode newNode = Refactor(node, configOptions).WithFormatterAnnotation();
+    private static NewLinePosition GetNewLinePosition(Document document, SyntaxNode node, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken)
+    {
+        if (DiagnosticRules.PutExpressionBodyOnItsOwnLine.IsEffective(node.SyntaxTree, document.Project.CompilationOptions, cancellationToken)
+            && ConvertExpressionBodyAnalysis.AllowPutExpressionBodyOnItsOwnLine(node.Kind()))
+        {
+            return configOptions.GetArrowTokenNewLinePosition();
+        }
 
-        return document.ReplaceNodeAsync(node, newNode, cancellationToken);
+        return NewLinePosition.None;
     }
 
-    private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions configOptions)
+    private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions configOptions, NewLinePosition newLinePosition)
     {
         switch (node.Kind())
         {
@@ -201,7 +227,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(methodDeclaration.Body);
 
                 return methodDeclaration
-                    .WithExpressionBody(CreateExpressionBody(analysis, methodDeclaration, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, methodDeclaration, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(methodDeclaration.Body, analysis))
                     .WithBody(null);
             }
@@ -211,7 +237,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(constructorDeclaration.Body);
 
                 return constructorDeclaration
-                    .WithExpressionBody(CreateExpressionBody(analysis, constructorDeclaration, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, constructorDeclaration, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(constructorDeclaration.Body, analysis))
                     .WithBody(null);
             }
@@ -221,7 +247,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(destructorDeclaration.Body);
 
                 return destructorDeclaration
-                    .WithExpressionBody(CreateExpressionBody(analysis, destructorDeclaration, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, destructorDeclaration, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(destructorDeclaration.Body, analysis))
                     .WithBody(null);
             }
@@ -231,7 +257,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(localFunction.Body);
 
                 return localFunction
-                    .WithExpressionBody(CreateExpressionBody(analysis, localFunction, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, localFunction, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(localFunction.Body, analysis))
                     .WithBody(null);
             }
@@ -241,7 +267,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(operatorDeclaration.Body);
 
                 return operatorDeclaration
-                    .WithExpressionBody(CreateExpressionBody(analysis, operatorDeclaration, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, operatorDeclaration, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(operatorDeclaration.Body, analysis))
                     .WithBody(null);
             }
@@ -251,7 +277,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(operatorDeclaration.Body);
 
                 return operatorDeclaration
-                    .WithExpressionBody(CreateExpressionBody(analysis, operatorDeclaration, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, operatorDeclaration, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(operatorDeclaration.Body, analysis))
                     .WithBody(null);
             }
@@ -261,7 +287,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(propertyDeclaration.AccessorList);
 
                 return propertyDeclaration
-                    .WithExpressionBody(CreateExpressionBody(analysis, propertyDeclaration, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, propertyDeclaration, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(analysis.Block, analysis))
                     .WithAccessorList(null);
             }
@@ -271,7 +297,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(indexerDeclaration.AccessorList);
 
                 return indexerDeclaration
-                    .WithExpressionBody(CreateExpressionBody(analysis, indexerDeclaration, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, indexerDeclaration, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(analysis.Block, analysis))
                     .WithAccessorList(null);
             }
@@ -285,7 +311,7 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
                 BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(accessor);
 
                 return accessor
-                    .WithExpressionBody(CreateExpressionBody(analysis, accessor, configOptions))
+                    .WithExpressionBody(CreateExpressionBody(analysis, accessor, configOptions, newLinePosition))
                     .WithSemicolonToken(CreateSemicolonToken(analysis.Block, analysis))
                     .WithBody(null);
             }
@@ -300,7 +326,8 @@ private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions config
     private static ArrowExpressionClauseSyntax CreateExpressionBody(
         BlockExpressionAnalysis analysis,
         SyntaxNode declaration,
-        AnalyzerConfigOptions configOptions)
+        AnalyzerConfigOptions configOptions,
+        NewLinePosition newLinePosition)
     {
         SyntaxToken arrowToken = Token(SyntaxKind.EqualsGreaterThanToken);
 
@@ -331,7 +358,20 @@ private static ArrowExpressionClauseSyntax CreateExpressionBody(
             }
         }
 
-        expression = SyntaxTriviaAnalysis.SetIndentation(expression, declaration, configOptions);
+        switch (newLinePosition)
+        {
+            case NewLinePosition.After:
+                arrowToken = arrowToken.AppendToTrailingTrivia(CSharpFactory.NewLine());
+                expression = SyntaxTriviaAnalysis.SetIndentation(expression, declaration, configOptions);
+                break;
+            case NewLinePosition.Before:
+                SyntaxTrivia trivia = SyntaxTriviaAnalysis.GetIncreasedIndentationTrivia(declaration, configOptions, CancellationToken.None);
+                arrowToken = arrowToken.WithLeadingTrivia(trivia);
+                break;
+            default:
+                expression = SyntaxTriviaAnalysis.SetIndentation(expression, declaration, configOptions);
+                break;
+        }
 
         return ArrowExpressionClause(arrowToken, expression);
     }