diff --git a/.editorconfig b/.editorconfig
index 1d4c9ced5b..ab81a354fb 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -6,6 +6,9 @@ root = true
 # Code files
 [*.{cs,csx}]
 
+indent_style = space
+indent_size = 4
+
 dotnet_sort_system_directives_first = true
 
 csharp_style_namespace_declarations = file_scoped:suggestion
diff --git a/ChangeLog.md b/ChangeLog.md
index bebc5db2a6..ac8853a0b1 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -39,6 +39,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix [RCS1208](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1208) ([#1153](https://github.com/JosefPihrt/Roslynator/pull/1153)).
 - Fix [RCS1043](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1043) ([#1176](https://github.com/JosefPihrt/Roslynator/pull/1176)).
 - [CLI] Fix exit code of `spellcheck` command ([#1177](https://github.com/JosefPihrt/Roslynator/pull/1177)).
+- Improve indentation analysis ([#1188](https://github.com/JosefPihrt/Roslynator/pull/1188)).
 
 ## [4.4.0] - 2023-08-01
 
diff --git a/src/Analyzers.xml b/src/Analyzers.xml
index 136339d3b9..24a119220a 100644
--- a/src/Analyzers.xml
+++ b/src/Analyzers.xml
@@ -1446,6 +1446,7 @@ void M(
 Default maximal length is 140.</Summary>
     <ConfigOptions>
       <Option Key="max_line_length" />
+      <Option Key="tab_length" />
     </ConfigOptions>
   </Analyzer>
   <Analyzer>
diff --git a/src/Analyzers/CSharp/Analysis/RemoveEmptySyntaxAnalyzer.cs b/src/Analyzers/CSharp/Analysis/RemoveEmptySyntaxAnalyzer.cs
index 03d5557cbc..f1318bb645 100644
--- a/src/Analyzers/CSharp/Analysis/RemoveEmptySyntaxAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analysis/RemoveEmptySyntaxAnalyzer.cs
@@ -66,7 +66,7 @@ private static void AnalyzeElseClause(SyntaxNodeAnalysisContext context)
         IfStatementSyntax topmostIf = elseClause.GetTopmostIf();
 
         if (topmostIf.Parent is IfStatementSyntax parentIf
-            && parentIf.Else != null)
+            && parentIf.Else is not null)
         {
             return;
         }
diff --git a/src/Analyzers/CSharp/Analysis/RemovePartialModifierFromTypeWithSinglePartAnalyzer.cs b/src/Analyzers/CSharp/Analysis/RemovePartialModifierFromTypeWithSinglePartAnalyzer.cs
index 37a784cdc8..4fcc5c2f96 100644
--- a/src/Analyzers/CSharp/Analysis/RemovePartialModifierFromTypeWithSinglePartAnalyzer.cs
+++ b/src/Analyzers/CSharp/Analysis/RemovePartialModifierFromTypeWithSinglePartAnalyzer.cs
@@ -14,7 +14,7 @@ public sealed class RemovePartialModifierFromTypeWithSinglePartAnalyzer : BaseDi
 {
     private static ImmutableArray<DiagnosticDescriptor> _supportedDiagnostics;
 
-    private static readonly MetadataName[] _metadataNames = new MetadataName[] {
+    private static readonly MetadataName[] _metadataNames = new[] {
         // ASP.NET Core
         MetadataName.Parse("Microsoft.AspNetCore.Components.ComponentBase"),
         // WPF
diff --git a/src/CodeFixes/CSharp/CodeFixes/AssignDefaultValueToOutParameterCodeFixProvider.cs b/src/CodeFixes/CSharp/CodeFixes/AssignDefaultValueToOutParameterCodeFixProvider.cs
index fb85bc8b84..54a044d07c 100644
--- a/src/CodeFixes/CSharp/CodeFixes/AssignDefaultValueToOutParameterCodeFixProvider.cs
+++ b/src/CodeFixes/CSharp/CodeFixes/AssignDefaultValueToOutParameterCodeFixProvider.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Roslynator.CodeFixes;
 using Roslynator.CSharp.Refactorings;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
@@ -155,7 +156,9 @@ private static Task<Document> RefactorAsync(
 
         if (bodyOrExpressionBody is ArrowExpressionClauseSyntax expressionBody)
         {
-            newNode = ConvertExpressionBodyToBlockBodyRefactoring.Refactor(expressionBody, semanticModel, cancellationToken);
+            AnalyzerConfigOptions configOptions = document.GetConfigOptions(node.SyntaxTree);
+
+            newNode = ConvertExpressionBodyToBlockBodyRefactoring.Refactor(expressionBody, configOptions, semanticModel, cancellationToken);
 
             newNode = InsertStatements(newNode, expressionStatements);
         }
diff --git a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
index e06730a91f..00fbc39fb7 100644
--- a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
+++ b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Josef Pihrt and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Globalization;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Roslynator.Configuration;
 using Roslynator.CSharp.CodeStyle;
@@ -9,6 +10,42 @@ namespace Roslynator.CSharp;
 
 internal static class CodeStyleExtensions
 {
+    public static bool TryGetTabLength(this AnalyzerConfigOptions configOptions, out int tabLength)
+    {
+        if (configOptions.TryGetValue(ConfigOptionKeys.TabLength, out string tabLengthStr)
+            && int.TryParse(tabLengthStr, NumberStyles.None, CultureInfo.InvariantCulture, out tabLength))
+        {
+            return true;
+        }
+
+        tabLength = 0;
+        return false;
+    }
+
+    public static bool TryGetIndentSize(this AnalyzerConfigOptions configOptions, out int indentSize)
+    {
+        if (configOptions.TryGetValue("indent_size", out string indentSizeStr)
+            && int.TryParse(indentSizeStr, NumberStyles.None, CultureInfo.InvariantCulture, out indentSize))
+        {
+            return true;
+        }
+
+        indentSize = 0;
+        return false;
+    }
+
+    public static bool TryGetIndentStyle(this AnalyzerConfigOptions configOptions, out IndentStyle indentStyle)
+    {
+        if (configOptions.TryGetValue("indent_style", out string indentStyleStr)
+            && Enum.TryParse(indentStyleStr, ignoreCase: true, out indentStyle))
+        {
+            return true;
+        }
+
+        indentStyle = IndentStyle.Space;
+        return false;
+    }
+
     public static bool GetPrefixFieldIdentifierWithUnderscore(this AnalyzerConfigOptions configOptions)
     {
         if (configOptions.TryGetValueAsBool(ConfigOptions.PrefixFieldIdentifierWithUnderscore, out bool value))
diff --git a/src/CSharp/CSharp/IndentationAnalysis.cs b/src/Common/CSharp/IndentationAnalysis.cs
similarity index 83%
rename from src/CSharp/CSharp/IndentationAnalysis.cs
rename to src/Common/CSharp/IndentationAnalysis.cs
index 0de4dda8cc..74b8bdb931 100644
--- a/src/CSharp/CSharp/IndentationAnalysis.cs
+++ b/src/Common/CSharp/IndentationAnalysis.cs
@@ -5,62 +5,86 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 
 namespace Roslynator.CSharp;
 
 [DebuggerDisplay("{DebuggerDisplay,nq}")]
-internal readonly struct IndentationAnalysis
+internal sealed class IndentationAnalysis
 {
     private readonly int? _indentSize;
-    private readonly SyntaxTrivia? _singleIndentation;
+    private readonly SyntaxTrivia? _indentStep;
 
-    private IndentationAnalysis(SyntaxTrivia indentation, int? indentSize, SyntaxTrivia? singleIndentation)
+    private IndentationAnalysis(SyntaxTrivia indentation, IndentStyle? indentStyle, int? indentSize, SyntaxTrivia? indentStep)
     {
         Indentation = indentation;
+        IndentStyle = indentStyle;
         _indentSize = indentSize;
-        _singleIndentation = singleIndentation;
+        _indentStep = indentStep;
     }
 
     public SyntaxTrivia Indentation { get; }
 
-    public int IndentSize => _indentSize ?? _singleIndentation?.Span.Length ?? 0;
+    public IndentStyle? IndentStyle { get; }
 
-    public int IndentationLength => Indentation.Span.Length;
+    public int IndentSize => _indentSize ?? _indentStep?.Span.Length ?? 0;
 
-    public int IncreasedIndentationLength => (IndentSize > 0) ? Indentation.Span.Length + IndentSize : 0;
+    public int IndentationLength => Indentation.Span.Length;
 
-    public bool IsDefault
+    public int IncreasedIndentationLength
     {
         get
         {
-            return Indentation.IsKind(SyntaxKind.None)
-                && _indentSize is null
-                && _singleIndentation is null;
+            if (IndentSize > 0)
+            {
+                if (IndentStyle == Roslynator.IndentStyle.Tab)
+                    return IndentationLength + 1;
+
+                return IndentationLength + IndentSize;
+            }
+
+            if (_indentStep is not null)
+                return IndentationLength + 4;
+
+            return IndentationLength;
         }
     }
 
     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-    private string DebuggerDisplay => $"Length = {Indentation.Span.Length} {nameof(IndentSize)} = {IndentSize}";
+    private string DebuggerDisplay => $"Length = {IndentationLength} {nameof(IndentSize)} = {IndentSize}";
 
-    public static IndentationAnalysis Create(SyntaxNode node, CancellationToken cancellationToken = default)
+    public static IndentationAnalysis Create(SyntaxNode node, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
         SyntaxTrivia indentation = SyntaxTriviaAnalysis.DetermineIndentation(node, cancellationToken);
 
+        if (configOptions.TryGetIndentStyle(out IndentStyle indentStyle)
+            && indentStyle == Roslynator.IndentStyle.Tab)
+        {
+            if (!configOptions.TryGetTabLength(out int tabLength))
+                tabLength = 4;
+
+            return new IndentationAnalysis(indentation, indentStyle, tabLength, null);
+        }
+        else if (configOptions.TryGetIndentSize(out int indentSize))
+        {
+            return new IndentationAnalysis(indentation, Roslynator.IndentStyle.Space, indentSize, null);
+        }
+
         (SyntaxTrivia trivia1, SyntaxTrivia trivia2, bool isFromCompilationUnit) = DetermineSingleIndentation(node, cancellationToken);
 
         if (isFromCompilationUnit)
         {
-            return new IndentationAnalysis(indentation, trivia1.Span.Length - trivia2.Span.Length, null);
+            return new IndentationAnalysis(indentation, null, trivia1.Span.Length - trivia2.Span.Length, null);
         }
         else if (indentation.Span.Length > 0)
         {
             return (trivia1.Span.Length > 0)
-                ? new IndentationAnalysis(indentation, null, trivia1)
-                : new IndentationAnalysis(indentation, null, null);
+                ? new IndentationAnalysis(indentation, null, null, trivia1)
+                : new IndentationAnalysis(indentation, null, null, null);
         }
         else if (trivia1.Span.Length > 0)
         {
-            return new IndentationAnalysis(indentation, null, trivia1);
+            return new IndentationAnalysis(indentation, null, null, trivia1);
         }
         else
         {
@@ -87,11 +111,14 @@ public SyntaxTriviaList GetIncreasedIndentationTriviaList()
 
     public string GetSingleIndentation()
     {
-        if (_singleIndentation is not null)
-            return _singleIndentation.ToString();
+        if (_indentStep is not null)
+            return _indentStep.ToString();
+
+        if (IndentStyle == Roslynator.IndentStyle.Tab)
+            return "\t";
 
-        if (_indentSize == -1)
-            return Indentation.ToString();
+        if (IndentStyle == Roslynator.IndentStyle.Space)
+            return GetSpaces();
 
         if (Indentation.Span.Length == 0)
             return "";
@@ -101,7 +128,18 @@ public string GetSingleIndentation()
         if (indentation[indentation.Length - 1] == '\t')
             return "\t";
 
-        return new string(indentation[0], IndentSize);
+        return GetSpaces();
+
+        string GetSpaces()
+        {
+            return IndentSize switch
+            {
+                2 => "  ",
+                4 => "    ",
+                8 => "        ",
+                _ => new string(' ', IndentSize),
+            };
+        }
     }
 
     private static (SyntaxTrivia, SyntaxTrivia, bool isFromCompilationUnit) DetermineSingleIndentation(SyntaxNode node, CancellationToken cancellationToken = default)
diff --git a/src/CSharp/CSharp/SyntaxTriviaAnalysis.cs b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
similarity index 93%
rename from src/CSharp/CSharp/SyntaxTriviaAnalysis.cs
rename to src/Common/CSharp/SyntaxTriviaAnalysis.cs
index d185efe922..2c8f052462 100644
--- a/src/CSharp/CSharp/SyntaxTriviaAnalysis.cs
+++ b/src/Common/CSharp/SyntaxTriviaAnalysis.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
 using Roslynator.CSharp;
 using Roslynator.Text;
@@ -201,9 +202,9 @@ public static bool StartsWithOptionalWhitespaceThenEndOfLineTrivia(SyntaxTriviaL
         return en.Current.IsEndOfLineTrivia();
     }
 
-    public static IndentationAnalysis AnalyzeIndentation(SyntaxNode node, CancellationToken cancellationToken = default)
+    public static IndentationAnalysis AnalyzeIndentation(SyntaxNode node, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        return IndentationAnalysis.Create(node, cancellationToken);
+        return IndentationAnalysis.Create(node, configOptions, cancellationToken);
     }
 
     public static SyntaxTrivia DetermineIndentation(SyntaxNodeOrToken nodeOrToken, CancellationToken cancellationToken = default)
@@ -302,24 +303,19 @@ static bool IsMemberDeclarationOrStatementOrAccessorDeclaration(SyntaxNode node)
         }
     }
 
-    public static string GetIncreasedIndentation(SyntaxNode node, CancellationToken cancellationToken = default)
+    public static string GetIncreasedIndentation(SyntaxNode node, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        return AnalyzeIndentation(node, cancellationToken).GetIncreasedIndentation();
+        return AnalyzeIndentation(node, configOptions, cancellationToken).GetIncreasedIndentation();
     }
 
-    public static int GetIncreasedIndentationLength(SyntaxNode node, CancellationToken cancellationToken = default)
+    public static SyntaxTrivia GetIncreasedIndentationTrivia(SyntaxNode node, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        return AnalyzeIndentation(node, cancellationToken).IncreasedIndentationLength;
+        return AnalyzeIndentation(node, configOptions, cancellationToken).GetIncreasedIndentationTrivia();
     }
 
-    public static SyntaxTrivia GetIncreasedIndentationTrivia(SyntaxNode node, CancellationToken cancellationToken = default)
+    public static SyntaxTriviaList GetIncreasedIndentationTriviaList(SyntaxNode node, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        return AnalyzeIndentation(node, cancellationToken).GetIncreasedIndentationTrivia();
-    }
-
-    public static SyntaxTriviaList GetIncreasedIndentationTriviaList(SyntaxNode node, CancellationToken cancellationToken = default)
-    {
-        return AnalyzeIndentation(node, cancellationToken).GetIncreasedIndentationTriviaList();
+        return AnalyzeIndentation(node, configOptions, cancellationToken).GetIncreasedIndentationTriviaList();
     }
 
     public static IEnumerable<IndentationInfo> FindIndentations(SyntaxNode node)
@@ -367,9 +363,10 @@ public static IEnumerable<IndentationInfo> FindIndentations(SyntaxNode node, Tex
     public static TNode SetIndentation<TNode>(
         TNode expression,
         SyntaxNode containingDeclaration,
+        AnalyzerConfigOptions configOptions,
         int increaseCount = 0) where TNode : SyntaxNode
     {
-        IndentationAnalysis analysis = AnalyzeIndentation(containingDeclaration);
+        IndentationAnalysis analysis = AnalyzeIndentation(containingDeclaration, configOptions);
 
         string replacement = (increaseCount > 0)
             ? string.Concat(Enumerable.Repeat(analysis.GetSingleIndentation(), increaseCount))
diff --git a/src/Common/ConfigOptionKeys.Generated.cs b/src/Common/ConfigOptionKeys.Generated.cs
index 18b43bc31c..5c4844bfe2 100644
--- a/src/Common/ConfigOptionKeys.Generated.cs
+++ b/src/Common/ConfigOptionKeys.Generated.cs
@@ -35,6 +35,7 @@ internal static partial class ConfigOptionKeys
         public const string ObjectCreationTypeStyle                           = "roslynator_object_creation_type_style";
         public const string PrefixFieldIdentifierWithUnderscore               = "roslynator_prefix_field_identifier_with_underscore";
         public const string SuppressUnityScriptMethods                        = "roslynator_suppress_unity_script_methods";
+        public const string TabLength                                         = "roslynator_tab_length";
         public const string UseAnonymousFunctionOrMethodGroup                 = "roslynator_use_anonymous_function_or_method_group";
         public const string UseBlockBodyWhenDeclarationSpansOverMultipleLines = "roslynator_use_block_body_when_declaration_spans_over_multiple_lines";
         public const string UseBlockBodyWhenExpressionSpansOverMultipleLines  = "roslynator_use_block_body_when_expression_spans_over_multiple_lines";
diff --git a/src/Common/ConfigOptions.Generated.cs b/src/Common/ConfigOptions.Generated.cs
index 3a84f2d161..ca1648383a 100644
--- a/src/Common/ConfigOptions.Generated.cs
+++ b/src/Common/ConfigOptions.Generated.cs
@@ -182,6 +182,12 @@ public static partial class ConfigOptions
             defaultValuePlaceholder: "true|false", 
             description:             "Suppress Unity script methods");
 
+        public static readonly ConfigOptionDescriptor TabLength = new(
+            key:                     ConfigOptionKeys.TabLength, 
+            defaultValue:            "4", 
+            defaultValuePlaceholder: "<NUM>", 
+            description:             "A length of a tab character.");
+
         public static readonly ConfigOptionDescriptor UseAnonymousFunctionOrMethodGroup = new(
             key:                     ConfigOptionKeys.UseAnonymousFunctionOrMethodGroup, 
             defaultValue:            null, 
diff --git a/src/Common/IndentStyle.cs b/src/Common/IndentStyle.cs
new file mode 100644
index 0000000000..47ff3c822c
--- /dev/null
+++ b/src/Common/IndentStyle.cs
@@ -0,0 +1,9 @@
+// Copyright (c) Josef Pihrt and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Roslynator;
+
+public enum IndentStyle
+{
+    Space,
+    Tab,
+}
diff --git a/src/ConfigOptions.xml b/src/ConfigOptions.xml
index 8c2f55806a..06fafe0530 100644
--- a/src/ConfigOptions.xml
+++ b/src/ConfigOptions.xml
@@ -124,6 +124,11 @@
     <ValuePlaceholder>&lt;NUM&gt;</ValuePlaceholder>
     <Description>Max line length</Description>
   </Option>
+  <Option Id="TabLength">
+    <DefaultValue>4</DefaultValue>
+    <ValuePlaceholder>&lt;NUM&gt;</ValuePlaceholder>
+    <Description>A number of spaces that are equivalent to a tab character.</Description>
+  </Option>
   <Option Id="NewLineAtEndOfFile">
     <ValuePlaceholder>true|false</ValuePlaceholder>
     <Description>Include/omit new line at the end of a file</Description>
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/CodeFixHelpers.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/CodeFixHelpers.cs
index 29b989e230..d2f9102063 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/CodeFixHelpers.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/CodeFixHelpers.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
 using Roslynator.CSharp;
 using Roslynator.CSharp.CodeStyle;
@@ -78,7 +79,7 @@ public static Task<Document> AddNewLineBeforeAndIncreaseIndentationAsync(
         return AddNewLineBeforeAndIncreaseIndentationAsync(
             document,
             token,
-            AnalyzeIndentation(token.Parent, cancellationToken),
+            AnalyzeIndentation(token.Parent, document.GetConfigOptions(token.SyntaxTree), cancellationToken),
             cancellationToken);
     }
 
@@ -103,7 +104,7 @@ public static Task<Document> AddNewLineAfterAndIncreaseIndentationAsync(
         return AddNewLineAfterAndIncreaseIndentationAsync(
             document,
             token,
-            AnalyzeIndentation(token.Parent, cancellationToken),
+            AnalyzeIndentation(token.Parent, document.GetConfigOptions(token.SyntaxTree), cancellationToken),
             cancellationToken);
     }
 
@@ -429,7 +430,7 @@ public static Task<Document> FixCallChainAsync(
     {
         NewLinePosition conditionalAccessOperatorNewLinePosition = document.GetConfigOptions(expression.SyntaxTree).GetNullConditionalOperatorNewLinePosition(NewLinePosition.After);
 
-        IndentationAnalysis indentationAnalysis = AnalyzeIndentation(expression, cancellationToken);
+        IndentationAnalysis indentationAnalysis = AnalyzeIndentation(expression, document.GetConfigOptions(expression.SyntaxTree), cancellationToken);
         string indentation = indentationAnalysis.GetIncreasedIndentation();
         string endOfLineAndIndentation = DetermineEndOfLine(expression).ToString() + indentation;
 
@@ -596,7 +597,9 @@ public static Task<Document> FixBinaryExpressionAsync(
         TextSpan span,
         CancellationToken cancellationToken)
     {
-        IndentationAnalysis indentationAnalysis = AnalyzeIndentation(binaryExpression, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(binaryExpression.SyntaxTree);
+
+        IndentationAnalysis indentationAnalysis = AnalyzeIndentation(binaryExpression, configOptions, cancellationToken);
 
         string indentation;
         if (indentationAnalysis.Indentation == binaryExpression.GetLeadingTrivia().LastOrDefault()
@@ -959,6 +962,7 @@ private static Task<Document> FixListAsync<TNode>(
         CancellationToken cancellationToken = default) where TNode : SyntaxNode
     {
         List<TextChange> textChanges = GetFixListChanges(
+            document,
             containingNode,
             openNodeOrToken,
             nodes,
@@ -971,13 +975,16 @@ private static Task<Document> FixListAsync<TNode>(
     }
 
     internal static List<TextChange> GetFixListChanges<TNode>(
+        Document document,
         SyntaxNode containingNode,
         SyntaxNodeOrToken openNodeOrToken,
         IReadOnlyList<TNode> nodes,
         ListFixMode fixMode = ListFixMode.Fix,
         CancellationToken cancellationToken = default) where TNode : SyntaxNode
     {
-        IndentationAnalysis indentationAnalysis = AnalyzeIndentation(containingNode, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(containingNode.SyntaxTree);
+
+        IndentationAnalysis indentationAnalysis = AnalyzeIndentation(containingNode, configOptions, cancellationToken);
 
         string increasedIndentation = indentationAnalysis.GetIncreasedIndentation();
 
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/LineIsTooLong/LineIsTooLongCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/LineIsTooLong/LineIsTooLongCodeFixProvider.cs
index 77c7d03a9a..2f77ad0ca9 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/LineIsTooLong/LineIsTooLongCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/LineIsTooLong/LineIsTooLongCodeFixProvider.cs
@@ -205,7 +205,7 @@ private static Task<Document> AddNewLineBeforeOrAfterConditionalOperatorAsync(
         ConditionalExpressionSyntax conditionalExpression,
         CancellationToken cancellationToken = default)
     {
-        string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(conditionalExpression, cancellationToken);
+        string indentation = document.AnalyzeIndentation(conditionalExpression, cancellationToken).GetIncreasedIndentation();
 
         if (document.GetConfigOptions(conditionalExpression.SyntaxTree).GetEqualsTokenNewLinePosition() == NewLinePosition.After)
         {
@@ -235,7 +235,7 @@ private static Task<Document> AddNewLineBeforeOrAfterAsync(
         bool addNewLineAfter,
         CancellationToken cancellationToken = default)
     {
-        string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(token.Parent, cancellationToken);
+        string indentation = document.AnalyzeIndentation(token.Parent, cancellationToken).GetIncreasedIndentation();
 
         return (addNewLineAfter)
             ? AddNewLineAfterAsync(document, token, indentation, cancellationToken)
@@ -247,7 +247,7 @@ private static Task<Document> WrapForStatementAsync(
         ForStatementSyntax forStatement,
         CancellationToken cancellationToken = default)
     {
-        string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(forStatement, cancellationToken);
+        string indentation = document.AnalyzeIndentation(forStatement, cancellationToken).GetIncreasedIndentation();
 
         return document.WithTextChangesAsync(
             new TextChange[]
@@ -265,6 +265,7 @@ private static Task<Document> WrapBaseListAsync(
         CancellationToken cancellationToken = default)
     {
         List<TextChange> textChanges = GetFixListChanges(
+            document,
             baseList,
             baseList.ColonToken,
             baseList.Types,
@@ -280,6 +281,7 @@ private static Task<Document> WrapBaseListAsync(
             if (constraintClauses.Any())
             {
                 List<TextChange> textChanges2 = GetFixListChanges(
+                    document,
                     genericInfo.Node,
                     constraintClauses[0].WhereKeyword.GetPreviousToken(),
                     constraintClauses,
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/LineIsTooLong/WrapLineNodeFinder.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/LineIsTooLong/WrapLineNodeFinder.cs
index ea8c2c9cff..2a20e211c9 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/LineIsTooLong/WrapLineNodeFinder.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/LineIsTooLong/WrapLineNodeFinder.cs
@@ -225,7 +225,11 @@ private SyntaxNode GetFixableNode(SyntaxNode node)
                             forStatement.SecondSemicolonToken.Span.End - forStatement.Condition.SpanStart,
                             forStatement.CloseParenToken.Span.End - forStatement.Incrementors.Span.Start));
 
-                    int indentationLength = SyntaxTriviaAnalysis.GetIncreasedIndentationLength(node);
+                    IndentationAnalysis indentationAnalysis = IndentationAnalysis.Create(node, Document.GetConfigOptions(node.SyntaxTree));
+                    int indentationLength = indentationAnalysis.IncreasedIndentationLength;
+
+                    if (indentationAnalysis.IndentStyle == IndentStyle.Tab)
+                        indentationLength *= indentationAnalysis.IndentSize;
 
                     if (indentationLength + longestLength > MaxLineLength)
                         return null;
@@ -581,7 +585,7 @@ private bool CanWrap(
         if (wrapPosition - Span.Start > MaxLineLength)
             return false;
 
-        int indentationLength = SyntaxTriviaAnalysis.GetIncreasedIndentationLength(node);
+        int indentationLength = Document.AnalyzeIndentation(node).IncreasedIndentationLength;
 
         return indentationLength + longestLength <= MaxLineLength;
     }
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/MemberDeclarationCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/MemberDeclarationCodeFixProvider.cs
index a5bd7eb445..9cebc5b5bc 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/MemberDeclarationCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/MemberDeclarationCodeFixProvider.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Roslynator.CSharp;
 using Roslynator.Formatting.CSharp;
 
@@ -56,10 +57,12 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                         "Put constructor initializer on its own line",
                         ct =>
                         {
+                            AnalyzerConfigOptions configOptions = document.GetConfigOptions(memberDeclaration.SyntaxTree);
+
                             return CodeFixHelpers.AddNewLineBeforeAndIncreaseIndentationAsync(
                                 document,
                                 ((ConstructorDeclarationSyntax)memberDeclaration).Initializer.ColonToken,
-                                SyntaxTriviaAnalysis.AnalyzeIndentation(memberDeclaration, ct),
+                                SyntaxTriviaAnalysis.AnalyzeIndentation(memberDeclaration, configOptions, ct),
                                 ct);
                         },
                         GetEquivalenceKey(diagnostic));
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/TypeParameterConstraintClauseSyntaxCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/TypeParameterConstraintClauseSyntaxCodeFixProvider.cs
index 4c398907c0..1d6d07bc17 100644
--- a/src/Formatting.Analyzers.CodeFixes/CSharp/TypeParameterConstraintClauseSyntaxCodeFixProvider.cs
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/TypeParameterConstraintClauseSyntaxCodeFixProvider.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Roslynator.CSharp;
 using Roslynator.Formatting.CSharp;
 
@@ -35,10 +36,12 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             CodeFixTitles.AddNewLine,
             ct =>
             {
+                AnalyzerConfigOptions configOptions = document.GetConfigOptions(constraintClause.SyntaxTree);
+
                 return CodeFixHelpers.AddNewLineBeforeAndIncreaseIndentationAsync(
                     document,
                     constraintClause.WhereKeyword,
-                    SyntaxTriviaAnalysis.AnalyzeIndentation(constraintClause.Parent, ct),
+                    SyntaxTriviaAnalysis.AnalyzeIndentation(constraintClause.Parent, configOptions, ct),
                     ct);
             },
             GetEquivalenceKey(diagnostic));
diff --git a/src/Formatting.Analyzers/CSharp/FixFormattingOfBinaryExpressionChainAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixFormattingOfBinaryExpressionChainAnalyzer.cs
index b999ccfc54..155d0a1847 100644
--- a/src/Formatting.Analyzers/CSharp/FixFormattingOfBinaryExpressionChainAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixFormattingOfBinaryExpressionChainAnalyzer.cs
@@ -154,7 +154,7 @@ bool Analyze(SyntaxNodeOrToken nodeOrToken)
 
         int GetIndentationLength()
         {
-            IndentationAnalysis indentationAnalysis = AnalyzeIndentation(topBinaryExpression);
+            IndentationAnalysis indentationAnalysis = AnalyzeIndentation(topBinaryExpression, context.GetConfigOptions());
 
             if (indentationAnalysis.IndentSize == 0)
                 return -1;
diff --git a/src/Formatting.Analyzers/CSharp/FixFormattingOfCallChainAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixFormattingOfCallChainAnalyzer.cs
index 37c6604e28..3f7c0bc474 100644
--- a/src/Formatting.Analyzers/CSharp/FixFormattingOfCallChainAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixFormattingOfCallChainAnalyzer.cs
@@ -57,7 +57,7 @@ private static void AnalyzeExpression(SyntaxNodeAnalysisContext context)
 
         TextLineCollection lines = null;
         int startLine = -1;
-        IndentationAnalysis indentationAnalysis = default;
+        IndentationAnalysis indentationAnalysis = null;
 
         do
         {
@@ -122,13 +122,10 @@ bool AnalyzeToken(SyntaxToken token)
 
                 int endLine = lines.IndexOf(token.SpanStart);
 
-                if (startLine != endLine)
+                if (startLine != endLine
+                    && (indentationAnalysis ?? AnalyzeIndentation(expression, context.GetConfigOptions())).IndentSize > 0)
                 {
-                    if (!indentationAnalysis.IsDefault
-                        || !AnalyzeIndentation(expression).IsDefault)
-                    {
-                        ReportDiagnostic();
-                    }
+                    ReportDiagnostic();
                 }
 
                 return true;
@@ -138,11 +135,11 @@ bool AnalyzeToken(SyntaxToken token)
             {
                 case SyntaxKind.WhitespaceTrivia:
                     {
-                        if (indentationAnalysis.IsDefault)
+                        if (indentationAnalysis is null)
                         {
-                            indentationAnalysis = AnalyzeIndentation(expression);
+                            indentationAnalysis = AnalyzeIndentation(expression, context.GetConfigOptions());
 
-                            if (indentationAnalysis.IsDefault)
+                            if (indentationAnalysis.IndentSize == 0)
                                 return true;
                         }
 
@@ -167,8 +164,7 @@ bool AnalyzeToken(SyntaxToken token)
                     {
                         if (expression.FindTrivia(token.FullSpan.Start - 1).IsEndOfLineTrivia())
                         {
-                            if (!indentationAnalysis.IsDefault
-                                || !AnalyzeIndentation(expression).IsDefault)
+                            if ((indentationAnalysis ?? AnalyzeIndentation(expression, context.GetConfigOptions())).IndentSize > 0)
                             {
                                 ReportDiagnostic();
                             }
diff --git a/src/Formatting.Analyzers/CSharp/FixFormattingOfListAnalyzer.cs b/src/Formatting.Analyzers/CSharp/FixFormattingOfListAnalyzer.cs
index 7e92cf4874..46cbbe1c2b 100644
--- a/src/Formatting.Analyzers/CSharp/FixFormattingOfListAnalyzer.cs
+++ b/src/Formatting.Analyzers/CSharp/FixFormattingOfListAnalyzer.cs
@@ -157,7 +157,7 @@ private static void Analyze<TNode>(
             if (!IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailing))
                 return;
 
-            int indentationLength = GetIncreasedIndentationLength(openNodeOrToken.Parent);
+            int indentationLength = IndentationAnalysis.Create(openNodeOrToken.Parent, context.GetConfigOptions()).IncreasedIndentationLength;
 
             if (indentationLength == 0)
                 return;
@@ -169,7 +169,7 @@ private static void Analyze<TNode>(
         {
             TextLineCollection lines = null;
 
-            IndentationAnalysis indentationAnalysis = IndentationAnalysis.Create(openNodeOrToken.Parent);
+            IndentationAnalysis indentationAnalysis = IndentationAnalysis.Create(openNodeOrToken.Parent, context.GetConfigOptions());
 
             int indentationLength = indentationAnalysis.IncreasedIndentationLength;
 
diff --git a/src/Refactorings/CSharp/Refactorings/ExpandPositionalConstructorRefactoring.cs b/src/Refactorings/CSharp/Refactorings/ExpandPositionalConstructorRefactoring.cs
index 3a85ba0533..43dc07bb91 100644
--- a/src/Refactorings/CSharp/Refactorings/ExpandPositionalConstructorRefactoring.cs
+++ b/src/Refactorings/CSharp/Refactorings/ExpandPositionalConstructorRefactoring.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using static Roslynator.CSharp.CSharpFactory;
 
@@ -102,7 +103,9 @@ private static Task<Document> RefactorAsync(
         ParameterSyntax firstParameter = parameterList.Parameters[0];
         if (firstParameter.GetLeadingTrivia().SingleOrDefault(shouldThrow: false).IsKind(SyntaxKind.WhitespaceTrivia))
         {
-            SyntaxTriviaList newIndentation = SyntaxTriviaAnalysis.GetIncreasedIndentationTriviaList(firstParameter, cancellationToken);
+            AnalyzerConfigOptions configOptions = document.GetConfigOptions(recordDeclaration.SyntaxTree);
+
+            SyntaxTriviaList newIndentation = SyntaxTriviaAnalysis.GetIncreasedIndentationTriviaList(firstParameter, configOptions, cancellationToken);
 
             newParameterList = newParameterList.ReplaceNodes(
                 newParameterList.Parameters,
diff --git a/src/Refactorings/CSharp/Refactorings/WrapConstraintClausesRefactoring.cs b/src/Refactorings/CSharp/Refactorings/WrapConstraintClausesRefactoring.cs
index 6cbb1f5ce9..42b8861169 100644
--- a/src/Refactorings/CSharp/Refactorings/WrapConstraintClausesRefactoring.cs
+++ b/src/Refactorings/CSharp/Refactorings/WrapConstraintClausesRefactoring.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
 using Roslynator.CSharp.Syntax;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
@@ -29,7 +30,7 @@ public static void ComputeRefactoring(RefactoringContext context, TypeParameterC
                     "Wrap constraints",
                     ct =>
                     {
-                        GenericInfo newInfo = WrapConstraints(genericInfo);
+                        GenericInfo newInfo = WrapConstraints(genericInfo, context.Document.GetConfigOptions(constraintClause.SyntaxTree));
 
                         return context.Document.ReplaceNodeAsync(genericInfo.Node, newInfo.Node, ct);
                     },
@@ -82,7 +83,7 @@ private static GenericInfo UnwrapConstraints(in GenericInfo info)
         return SyntaxInfo.GenericInfo(declaration).WithConstraintClauses(constraintClauses);
     }
 
-    private static GenericInfo WrapConstraints(in GenericInfo info)
+    private static GenericInfo WrapConstraints(GenericInfo info, AnalyzerConfigOptions configOptions)
     {
         SyntaxNode declaration = info.Node;
         SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses = info.ConstraintClauses;
@@ -93,7 +94,7 @@ private static GenericInfo WrapConstraints(in GenericInfo info)
 
         declaration = declaration.ReplaceToken(previousToken, previousToken.WithTrailingTrivia(TriviaList(NewLine())));
 
-        SyntaxTrivia trivia = SyntaxTriviaAnalysis.GetIncreasedIndentationTrivia(declaration);
+        SyntaxTrivia trivia = SyntaxTriviaAnalysis.GetIncreasedIndentationTrivia(declaration, configOptions);
 
         int count = constraintClauses.Count;
 
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS0053FixFormattingOfListTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS0053FixFormattingOfListTests.cs
index 8dd14604b6..b6edbaf666 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS0053FixFormattingOfListTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS0053FixFormattingOfListTests.cs
@@ -621,7 +621,7 @@ void M(object x, string y)
 				.ToString());
 	}
 }
-");
+", options: Options.AddConfigOption("indent_style", "tab"));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixFormattingOfList)]
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS0054FixFormattingOfCallChainTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS0054FixFormattingOfCallChainTests.cs
index 238a356224..d29161b374 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS0054FixFormattingOfCallChainTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS0054FixFormattingOfCallChainTests.cs
@@ -389,23 +389,33 @@ void Main(string[] args)
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixFormattingOfCallChain)]
     public async Task Test_TopLevelStatement2()
     {
-        await VerifyNoDiagnosticAsync(@"
+        await VerifyDiagnosticAndFixAsync(@"
+var s = """";
+
+s = [|s.ToString().ToString()
+.ToString()|];
+", @"
 var s = """";
 
 s = s.ToString().ToString()
-.ToString();
+    .ToString();
 ", options: Options.WithCompilationOptions(Options.CompilationOptions.WithOutputKind(OutputKind.ConsoleApplication)));
     }
 
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixFormattingOfCallChain)]
     public async Task Test_TopLevelStatement3()
     {
-        await VerifyNoDiagnosticAsync(@"
+        await VerifyDiagnosticAndFixAsync(@"
 var s = """";
 
-s = s.ToString().ToString()
+s = [|s.ToString().ToString()
 
-.ToString();
+.ToString()|];
+", @"
+var s = """";
+
+s = s.ToString().ToString()
+    .ToString();
 ", options: Options.WithCompilationOptions(Options.CompilationOptions.WithOutputKind(OutputKind.ConsoleApplication)));
     }
 
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS0055FixFormattingOfBinaryExpressionChainTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS0055FixFormattingOfBinaryExpressionChainTests.cs
index 4a2b439490..16d99d60c9 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS0055FixFormattingOfBinaryExpressionChainTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS0055FixFormattingOfBinaryExpressionChainTests.cs
@@ -256,6 +256,30 @@ void M()
 ");
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixFormattingOfBinaryExpressionChain)]
+    public async Task TestDiagnostic_StringConcatInsideTopLevelAttribute()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+using System;
+
+[Obsolete([|""a""
++ ""b""
++ ""c""|])]
+class C
+{
+}
+        ", @"
+using System;
+
+[Obsolete(""a""
+    + ""b""
+    + ""c"")]
+class C
+{
+}
+        ");
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixFormattingOfBinaryExpressionChain)]
     public async Task TestNoDiagnostic()
     {
@@ -288,21 +312,6 @@ void M()
                 && y
                 && z;
     }
-}
-        ");
-    }
-
-    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.FixFormattingOfBinaryExpressionChain)]
-    public async Task TestNoDiagnostic_IndentationSizeCannotBeDetermined()
-    {
-        await VerifyNoDiagnosticAsync(@"
-using System;
-
-[Obsolete(""a""
-+ ""b""
-+ ""c"")]
-class C
-{
 }
         ");
     }
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS0056LineIsTooLongTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS0056LineIsTooLongTests.cs
index c500710560..83c639f29d 100644
--- a/src/Tests/Formatting.Analyzers.Tests/RCS0056LineIsTooLongTests.cs
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS0056LineIsTooLongTests.cs
@@ -699,6 +699,34 @@ string x
 ");
     }
 
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.LineIsTooLong)]
+    public async Task Test_Assignment2()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+class C
+{
+    static string foo()
+    {
+[|                                                                                                              string x = foo();|]
+
+        return null;
+    }
+}
+",
+@"
+class C
+{
+    static string foo()
+    {
+                                                                                                              string x
+                                                                                                                  = foo();
+
+        return null;
+    }
+}
+");
+    }
+
     [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.LineIsTooLong)]
     public async Task Test_AttributeList()
     {
diff --git a/src/Tests/Tests.Common/Testing/CSharp/DefaultCSharpTestOptions.cs b/src/Tests/Tests.Common/Testing/CSharp/DefaultCSharpTestOptions.cs
index 55e29f6eda..bce06f8f6e 100644
--- a/src/Tests/Tests.Common/Testing/CSharp/DefaultCSharpTestOptions.cs
+++ b/src/Tests/Tests.Common/Testing/CSharp/DefaultCSharpTestOptions.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Josef Pihrt and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp;
 
@@ -26,6 +27,11 @@ private static CSharpTestOptions Create()
 
         return CSharpTestOptions.Default
             .WithParseOptions(CSharpTestOptions.Default.ParseOptions.WithLanguageVersion(LanguageVersion.CSharp10))
-            .WithAllowedCompilerDiagnosticIds(allowedCompilerDiagnosticIds);
+            .WithAllowedCompilerDiagnosticIds(allowedCompilerDiagnosticIds)
+            .WithConfigOptions(new KeyValuePair<string, string>[]
+            {
+                new("indent_size", "4"),
+                new("indent_style", "space")
+            });
     }
 }
diff --git a/src/VisualStudioCode/package/src/configurationFiles.generated.ts b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
index 91d3b9d873..0d26a78d60 100644
--- a/src/VisualStudioCode/package/src/configurationFiles.generated.ts
+++ b/src/VisualStudioCode/package/src/configurationFiles.generated.ts
@@ -120,6 +120,10 @@ roslynator_analyzers.enabled_by_default = true|false
 #roslynator_suppress_unity_script_methods = true|false
 # Applicable to: rcs1213
 
+#roslynator_tab_length = <NUM>
+# Default: 4
+# Applicable to: rcs0056
+
 #roslynator_use_anonymous_function_or_method_group = anonymous_function|method_group
 # Applicable to: rcs1207
 
@@ -276,7 +280,7 @@ roslynator_analyzers.enabled_by_default = true|false
 
 # A line is too long
 #dotnet_diagnostic.rcs0056.severity = none
-# Options: roslynator_max_line_length
+# Options: roslynator_max_line_length, roslynator_tab_length
 
 # Normalize whitespace at the beginning of a file
 #dotnet_diagnostic.rcs0057.severity = none
diff --git a/src/Workspaces.Common/CSharp/Refactorings/ConvertBlockBodyToExpressionBodyRefactoring.cs b/src/Workspaces.Common/CSharp/Refactorings/ConvertBlockBodyToExpressionBodyRefactoring.cs
index b7d6812372..0180ed5712 100644
--- a/src/Workspaces.Common/CSharp/Refactorings/ConvertBlockBodyToExpressionBodyRefactoring.cs
+++ b/src/Workspaces.Common/CSharp/Refactorings/ConvertBlockBodyToExpressionBodyRefactoring.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
 using Roslynator.CSharp.Analysis;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
@@ -163,7 +164,9 @@ public static Task<Document> RefactorAsync(
                 {
                     if (CanRefactor(member))
                     {
-                        var newMember = (MemberDeclarationSyntax)Refactor(member);
+                        AnalyzerConfigOptions configOptions = document.GetConfigOptions(selectedMembers.Parent.SyntaxTree);
+
+                        var newMember = (MemberDeclarationSyntax)Refactor(member, configOptions);
 
                         return newMember
                             .WithTrailingTrivia(member.GetTrailingTrivia())
@@ -181,12 +184,14 @@ public static Task<Document> RefactorAsync(
         SyntaxNode node,
         CancellationToken cancellationToken = default)
     {
-        SyntaxNode newNode = Refactor(node).WithFormatterAnnotation();
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(node.SyntaxTree);
+
+        SyntaxNode newNode = Refactor(node, configOptions).WithFormatterAnnotation();
 
         return document.ReplaceNodeAsync(node, newNode, cancellationToken);
     }
 
-    private static SyntaxNode Refactor(SyntaxNode node)
+    private static SyntaxNode Refactor(SyntaxNode node, AnalyzerConfigOptions configOptions)
     {
         switch (node.Kind())
         {
@@ -196,7 +201,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(methodDeclaration.Body);
 
                     return methodDeclaration
-                        .WithExpressionBody(CreateExpressionBody(analysis, methodDeclaration))
+                        .WithExpressionBody(CreateExpressionBody(analysis, methodDeclaration, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(methodDeclaration.Body, analysis))
                         .WithBody(null);
                 }
@@ -206,7 +211,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(constructorDeclaration.Body);
 
                     return constructorDeclaration
-                        .WithExpressionBody(CreateExpressionBody(analysis, constructorDeclaration))
+                        .WithExpressionBody(CreateExpressionBody(analysis, constructorDeclaration, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(constructorDeclaration.Body, analysis))
                         .WithBody(null);
                 }
@@ -216,7 +221,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(destructorDeclaration.Body);
 
                     return destructorDeclaration
-                        .WithExpressionBody(CreateExpressionBody(analysis, destructorDeclaration))
+                        .WithExpressionBody(CreateExpressionBody(analysis, destructorDeclaration, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(destructorDeclaration.Body, analysis))
                         .WithBody(null);
                 }
@@ -226,7 +231,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(localFunction.Body);
 
                     return localFunction
-                        .WithExpressionBody(CreateExpressionBody(analysis, localFunction))
+                        .WithExpressionBody(CreateExpressionBody(analysis, localFunction, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(localFunction.Body, analysis))
                         .WithBody(null);
                 }
@@ -236,7 +241,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(operatorDeclaration.Body);
 
                     return operatorDeclaration
-                        .WithExpressionBody(CreateExpressionBody(analysis, operatorDeclaration))
+                        .WithExpressionBody(CreateExpressionBody(analysis, operatorDeclaration, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(operatorDeclaration.Body, analysis))
                         .WithBody(null);
                 }
@@ -246,7 +251,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(operatorDeclaration.Body);
 
                     return operatorDeclaration
-                        .WithExpressionBody(CreateExpressionBody(analysis, operatorDeclaration))
+                        .WithExpressionBody(CreateExpressionBody(analysis, operatorDeclaration, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(operatorDeclaration.Body, analysis))
                         .WithBody(null);
                 }
@@ -256,7 +261,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(propertyDeclaration.AccessorList);
 
                     return propertyDeclaration
-                        .WithExpressionBody(CreateExpressionBody(analysis, propertyDeclaration))
+                        .WithExpressionBody(CreateExpressionBody(analysis, propertyDeclaration, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(analysis.Block, analysis))
                         .WithAccessorList(null);
                 }
@@ -266,7 +271,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(indexerDeclaration.AccessorList);
 
                     return indexerDeclaration
-                        .WithExpressionBody(CreateExpressionBody(analysis, indexerDeclaration))
+                        .WithExpressionBody(CreateExpressionBody(analysis, indexerDeclaration, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(analysis.Block, analysis))
                         .WithAccessorList(null);
                 }
@@ -280,7 +285,7 @@ private static SyntaxNode Refactor(SyntaxNode node)
                     BlockExpressionAnalysis analysis = BlockExpressionAnalysis.Create(accessor);
 
                     return accessor
-                        .WithExpressionBody(CreateExpressionBody(analysis, accessor))
+                        .WithExpressionBody(CreateExpressionBody(analysis, accessor, configOptions))
                         .WithSemicolonToken(CreateSemicolonToken(analysis.Block, analysis))
                         .WithBody(null);
                 }
@@ -292,7 +297,10 @@ private static SyntaxNode Refactor(SyntaxNode node)
         }
     }
 
-    private static ArrowExpressionClauseSyntax CreateExpressionBody(BlockExpressionAnalysis analysis, SyntaxNode declaration)
+    private static ArrowExpressionClauseSyntax CreateExpressionBody(
+        BlockExpressionAnalysis analysis,
+        SyntaxNode declaration,
+        AnalyzerConfigOptions configOptions)
     {
         SyntaxToken arrowToken = Token(SyntaxKind.EqualsGreaterThanToken);
 
@@ -323,7 +331,7 @@ private static ArrowExpressionClauseSyntax CreateExpressionBody(BlockExpressionA
                 }
         }
 
-        expression = SyntaxTriviaAnalysis.SetIndentation(expression, declaration);
+        expression = SyntaxTriviaAnalysis.SetIndentation(expression, declaration, configOptions);
 
         return ArrowExpressionClause(arrowToken, expression);
     }
diff --git a/src/Workspaces.Common/CSharp/Refactorings/ConvertExpressionBodyToBlockBodyRefactoring.cs b/src/Workspaces.Common/CSharp/Refactorings/ConvertExpressionBodyToBlockBodyRefactoring.cs
index 7da0b04207..417945ff1d 100644
--- a/src/Workspaces.Common/CSharp/Refactorings/ConvertExpressionBodyToBlockBodyRefactoring.cs
+++ b/src/Workspaces.Common/CSharp/Refactorings/ConvertExpressionBodyToBlockBodyRefactoring.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Roslynator.CSharp.Analysis;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using static Roslynator.CSharp.CSharpFactory;
@@ -22,6 +23,8 @@ public static async Task<Document> RefactorAsync(
         MemberDeclarationListSelection selectedMembers,
         CancellationToken cancellationToken)
     {
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(selectedMembers.Parent.SyntaxTree);
+
         SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
         IEnumerable<MemberDeclarationSyntax> newMembers = selectedMembers
@@ -36,7 +39,7 @@ public static async Task<Document> RefactorAsync(
                     if (expressionBody is not null
                         && ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                     {
-                        return (MemberDeclarationSyntax)Refactor(expressionBody, semanticModel, cancellationToken);
+                        return (MemberDeclarationSyntax)Refactor(expressionBody, configOptions, semanticModel, cancellationToken);
                     }
 
                     return member;
@@ -50,9 +53,11 @@ public static async Task<Document> RefactorAsync(
         ArrowExpressionClauseSyntax expressionBody,
         CancellationToken cancellationToken = default)
     {
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(expressionBody.SyntaxTree);
+
         SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
-        SyntaxNode newNode = Refactor(expressionBody, semanticModel, cancellationToken);
+        SyntaxNode newNode = Refactor(expressionBody, configOptions, semanticModel, cancellationToken);
 
         SyntaxToken token = expressionBody.ArrowToken.GetPreviousToken();
 
@@ -68,6 +73,7 @@ public static async Task<Document> RefactorAsync(
 
     public static SyntaxNode Refactor(
         ArrowExpressionClauseSyntax expressionBody,
+        AnalyzerConfigOptions configOptions,
         SemanticModel semanticModel,
         CancellationToken cancellationToken)
     {
@@ -84,7 +90,7 @@ public static SyntaxNode Refactor(
                     return method
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default)
-                        .WithBody(CreateBlock(method, expression, method.SemicolonToken, method.ReturnType, semanticModel, cancellationToken));
+                        .WithBody(CreateBlock(method, expression, method.SemicolonToken, method.ReturnType, configOptions, semanticModel, cancellationToken));
                 }
             case SyntaxKind.ConstructorDeclaration:
                 {
@@ -93,7 +99,7 @@ public static SyntaxNode Refactor(
                     return constructor
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default)
-                        .WithBody(CreateBlockWithExpressionStatement(constructor, expression, constructor.SemicolonToken));
+                        .WithBody(CreateBlockWithExpressionStatement(constructor, expression, constructor.SemicolonToken, configOptions));
                 }
             case SyntaxKind.DestructorDeclaration:
                 {
@@ -102,7 +108,7 @@ public static SyntaxNode Refactor(
                     return destructor
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default)
-                        .WithBody(CreateBlockWithExpressionStatement(destructor, expression, destructor.SemicolonToken));
+                        .WithBody(CreateBlockWithExpressionStatement(destructor, expression, destructor.SemicolonToken, configOptions));
                 }
             case SyntaxKind.OperatorDeclaration:
                 {
@@ -111,7 +117,7 @@ public static SyntaxNode Refactor(
                     return operatorDeclaration
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default)
-                        .WithBody(CreateBlock(operatorDeclaration, expression, operatorDeclaration.SemicolonToken));
+                        .WithBody(CreateBlock(operatorDeclaration, expression, operatorDeclaration.SemicolonToken, configOptions));
                 }
             case SyntaxKind.ConversionOperatorDeclaration:
                 {
@@ -120,14 +126,14 @@ public static SyntaxNode Refactor(
                     return conversionOperatorDeclaration
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default)
-                        .WithBody(CreateBlock(conversionOperatorDeclaration, expression, conversionOperatorDeclaration.SemicolonToken));
+                        .WithBody(CreateBlock(conversionOperatorDeclaration, expression, conversionOperatorDeclaration.SemicolonToken, configOptions));
                 }
             case SyntaxKind.PropertyDeclaration:
                 {
                     var propertyDeclaration = (PropertyDeclarationSyntax)node;
 
                     return propertyDeclaration
-                        .WithAccessorList(CreateAccessorList(propertyDeclaration, expression, propertyDeclaration.SemicolonToken))
+                        .WithAccessorList(CreateAccessorList(propertyDeclaration, expression, propertyDeclaration.SemicolonToken, configOptions))
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default);
                 }
@@ -136,7 +142,7 @@ public static SyntaxNode Refactor(
                     var indexerDeclaration = (IndexerDeclarationSyntax)node;
 
                     return indexerDeclaration
-                        .WithAccessorList(CreateAccessorList(indexerDeclaration, expression, indexerDeclaration.SemicolonToken))
+                        .WithAccessorList(CreateAccessorList(indexerDeclaration, expression, indexerDeclaration.SemicolonToken, configOptions))
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default);
                 }
@@ -147,7 +153,7 @@ public static SyntaxNode Refactor(
                     return accessor
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default)
-                        .WithBody(CreateBlock(accessor, expression, accessor.SemicolonToken));
+                        .WithBody(CreateBlock(accessor, expression, accessor.SemicolonToken, configOptions));
                 }
             case SyntaxKind.SetAccessorDeclaration:
             case SyntaxKind.InitAccessorDeclaration:
@@ -159,7 +165,7 @@ public static SyntaxNode Refactor(
                     return accessor
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default)
-                        .WithBody(CreateBlockWithExpressionStatement(accessor, expression, accessor.SemicolonToken));
+                        .WithBody(CreateBlockWithExpressionStatement(accessor, expression, accessor.SemicolonToken, configOptions));
                 }
             case SyntaxKind.LocalFunctionStatement:
                 {
@@ -168,7 +174,7 @@ public static SyntaxNode Refactor(
                     return localFunction
                         .WithExpressionBody(null)
                         .WithSemicolonToken(default)
-                        .WithBody(CreateBlock(localFunction, expression, localFunction.SemicolonToken, localFunction.ReturnType, semanticModel, cancellationToken));
+                        .WithBody(CreateBlock(localFunction, expression, localFunction.SemicolonToken, localFunction.ReturnType, configOptions, semanticModel, cancellationToken));
                 }
             default:
                 {
@@ -178,11 +184,16 @@ public static SyntaxNode Refactor(
         }
     }
 
-    private static BlockSyntax CreateBlock(SyntaxNode declaration, ExpressionSyntax expression, SyntaxToken semicolon, int increaseCount = 1)
+    private static BlockSyntax CreateBlock(
+        SyntaxNode declaration,
+        ExpressionSyntax expression,
+        SyntaxToken semicolon,
+        AnalyzerConfigOptions configOptions,
+        int increaseCount = 1)
     {
         return (expression.IsKind(SyntaxKind.ThrowExpression))
-            ? CreateBlockWithExpressionStatement(declaration, expression, semicolon, increaseCount)
-            : CreateBlockWithReturnStatement(declaration, expression, semicolon, increaseCount);
+            ? CreateBlockWithExpressionStatement(declaration, expression, semicolon, configOptions, increaseCount)
+            : CreateBlockWithReturnStatement(declaration, expression, semicolon, configOptions, increaseCount);
     }
 
     private static BlockSyntax CreateBlock(
@@ -190,12 +201,13 @@ private static BlockSyntax CreateBlock(
         ExpressionSyntax expression,
         SyntaxToken semicolon,
         TypeSyntax returnType,
+        AnalyzerConfigOptions configOptions,
         SemanticModel semanticModel,
         CancellationToken cancellationToken)
     {
         return (ShouldCreateExpressionStatement(returnType, expression, semanticModel, cancellationToken))
-            ? CreateBlockWithExpressionStatement(declaration, expression, semicolon)
-            : CreateBlockWithReturnStatement(declaration, expression, semicolon);
+            ? CreateBlockWithExpressionStatement(declaration, expression, semicolon, configOptions)
+            : CreateBlockWithReturnStatement(declaration, expression, semicolon, configOptions);
 
         static bool ShouldCreateExpressionStatement(
             TypeSyntax returnType,
@@ -238,9 +250,10 @@ static bool ShouldCreateExpressionStatement(
     private static AccessorListSyntax CreateAccessorList(
         SyntaxNode declaration,
         ExpressionSyntax expression,
-        SyntaxToken semicolon)
+        SyntaxToken semicolon,
+        AnalyzerConfigOptions configOptions)
     {
-        BlockSyntax block = CreateBlock(declaration, expression, semicolon, increaseCount: 2);
+        BlockSyntax block = CreateBlock(declaration, expression, semicolon, configOptions, increaseCount: 2);
 
         AccessorListSyntax accessorList = AccessorList(GetAccessorDeclaration(block));
 
@@ -259,12 +272,14 @@ private static BlockSyntax CreateBlockWithExpressionStatement(
         SyntaxNode declaration,
         ExpressionSyntax expression,
         SyntaxToken semicolon,
+        AnalyzerConfigOptions configOptions,
         int increaseCount = 1)
     {
         return CreateBlock(
             declaration,
             expression,
             semicolon,
+            configOptions,
             (e, s) =>
             {
                 if (e is ThrowExpressionSyntax throwExpression)
@@ -283,12 +298,14 @@ private static BlockSyntax CreateBlockWithReturnStatement(
         SyntaxNode declaration,
         ExpressionSyntax expression,
         SyntaxToken semicolon,
+        AnalyzerConfigOptions configOptions,
         int increaseCount = 1)
     {
         return CreateBlock(
             declaration,
             expression,
             semicolon,
+            configOptions,
             (e, s) => ReturnStatement(Token(SyntaxKind.ReturnKeyword), e, s),
             increaseCount: increaseCount);
     }
@@ -297,10 +314,11 @@ private static BlockSyntax CreateBlock(
         SyntaxNode declaration,
         ExpressionSyntax expression,
         SyntaxToken semicolon,
+        AnalyzerConfigOptions configOptions,
         Func<ExpressionSyntax, SyntaxToken, StatementSyntax> createStatement,
         int increaseCount = 1)
     {
-        expression = SyntaxTriviaAnalysis.SetIndentation(expression, declaration, increaseCount: increaseCount);
+        expression = SyntaxTriviaAnalysis.SetIndentation(expression, declaration, configOptions, increaseCount: increaseCount);
 
         return Block(
             Token(SyntaxKind.OpenBraceToken).WithFormatterAnnotation(),
diff --git a/src/Workspaces.Common/CSharp/Refactorings/UseMethodChainingRefactoring.cs b/src/Workspaces.Common/CSharp/Refactorings/UseMethodChainingRefactoring.cs
index 0435ccb5f5..335a509cd4 100644
--- a/src/Workspaces.Common/CSharp/Refactorings/UseMethodChainingRefactoring.cs
+++ b/src/Workspaces.Common/CSharp/Refactorings/UseMethodChainingRefactoring.cs
@@ -36,7 +36,7 @@ public static async Task<Document> RefactorAsync(
 
         int index = statements.IndexOf(expressionStatement);
 
-        string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(expressionStatement, cancellationToken);
+        string indentation = SyntaxTriviaAnalysis.GetIncreasedIndentation(expressionStatement, document.GetConfigOptions(expressionStatement.SyntaxTree), cancellationToken);
 
         var sb = new StringBuilder(invocationExpression.ToString());
 
diff --git a/src/CSharp.Workspaces/CSharp/SyntaxFormatter.cs b/src/Workspaces.Common/CSharp/SyntaxFormatter.cs
similarity index 89%
rename from src/CSharp.Workspaces/CSharp/SyntaxFormatter.cs
rename to src/Workspaces.Common/CSharp/SyntaxFormatter.cs
index d1e3b524d8..20d6d6a471 100644
--- a/src/CSharp.Workspaces/CSharp/SyntaxFormatter.cs
+++ b/src/Workspaces.Common/CSharp/SyntaxFormatter.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
 using Roslynator.CSharp.SyntaxRewriters;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
@@ -194,14 +195,16 @@ public static Task<Document> WrapConditionalExpressionAsync(
         ConditionalExpressionSyntax conditionalExpression,
         CancellationToken cancellationToken = default)
     {
-        ConditionalExpressionSyntax newNode = ToMultiLine(conditionalExpression, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(conditionalExpression.SyntaxTree);
+
+        ConditionalExpressionSyntax newNode = ToMultiLine(conditionalExpression, configOptions, cancellationToken);
 
         return document.ReplaceNodeAsync(conditionalExpression, newNode, cancellationToken);
     }
 
-    public static ConditionalExpressionSyntax ToMultiLine(ConditionalExpressionSyntax conditionalExpression, CancellationToken cancellationToken = default)
+    public static ConditionalExpressionSyntax ToMultiLine(ConditionalExpressionSyntax conditionalExpression, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(conditionalExpression, cancellationToken);
+        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(conditionalExpression, configOptions, cancellationToken);
 
         leadingTrivia = leadingTrivia.Insert(0, DetermineEndOfLine(conditionalExpression));
 
@@ -218,14 +221,16 @@ public static Task<Document> WrapParametersAsync(
         ParameterListSyntax parameterList,
         CancellationToken cancellationToken = default)
     {
-        ParameterListSyntax newNode = WrapParameters(parameterList, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(parameterList.SyntaxTree);
+
+        ParameterListSyntax newNode = WrapParameters(parameterList, configOptions, cancellationToken);
 
         return document.ReplaceNodeAsync(parameterList, newNode, cancellationToken);
     }
 
-    public static ParameterListSyntax WrapParameters(ParameterListSyntax parameterList, CancellationToken cancellationToken = default)
+    public static ParameterListSyntax WrapParameters(ParameterListSyntax parameterList, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(parameterList, cancellationToken);
+        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(parameterList, configOptions, cancellationToken);
 
         var nodesAndTokens = new List<SyntaxNodeOrToken>();
 
@@ -256,14 +261,16 @@ public static Task<Document> WrapParametersAsync(
         BracketedParameterListSyntax parameterList,
         CancellationToken cancellationToken = default)
     {
-        BracketedParameterListSyntax newNode = WrapParameters(parameterList, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(parameterList.SyntaxTree);
+
+        BracketedParameterListSyntax newNode = WrapParameters(parameterList, configOptions, cancellationToken);
 
         return document.ReplaceNodeAsync(parameterList, newNode, cancellationToken);
     }
 
-    public static BracketedParameterListSyntax WrapParameters(BracketedParameterListSyntax parameterList, CancellationToken cancellationToken = default)
+    public static BracketedParameterListSyntax WrapParameters(BracketedParameterListSyntax parameterList, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(parameterList, cancellationToken);
+        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(parameterList, configOptions, cancellationToken);
 
         var nodesAndTokens = new List<SyntaxNodeOrToken>();
 
@@ -294,13 +301,15 @@ public static Task<Document> ToMultiLineAsync(
         InitializerExpressionSyntax initializer,
         CancellationToken cancellationToken = default)
     {
-        InitializerExpressionSyntax newNode = ToMultiLine(initializer, cancellationToken)
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(initializer.SyntaxTree);
+
+        InitializerExpressionSyntax newNode = ToMultiLine(initializer, configOptions, cancellationToken)
             .WithFormatterAnnotation();
 
         return document.ReplaceNodeAsync(initializer, newNode, cancellationToken);
     }
 
-    public static InitializerExpressionSyntax ToMultiLine(InitializerExpressionSyntax initializer, CancellationToken cancellationToken)
+    public static InitializerExpressionSyntax ToMultiLine(InitializerExpressionSyntax initializer, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken)
     {
         SyntaxNode parent = initializer.Parent;
 
@@ -316,7 +325,7 @@ public static InitializerExpressionSyntax ToMultiLine(InitializerExpressionSynta
         }
         else
         {
-            IndentationAnalysis indentationAnalysis = AnalyzeIndentation(initializer, cancellationToken);
+            IndentationAnalysis indentationAnalysis = AnalyzeIndentation(initializer, configOptions, cancellationToken);
 
             SyntaxTriviaList braceTrivia = TriviaList(endOfLine, indentationAnalysis.Indentation);
             SyntaxTriviaList expressionTrivia = TriviaList(endOfLine, indentationAnalysis.GetIncreasedIndentationTrivia());
@@ -335,14 +344,16 @@ public static Task<Document> WrapArgumentsAsync(
         ArgumentListSyntax argumentList,
         CancellationToken cancellationToken = default)
     {
-        ArgumentListSyntax newNode = ToMultiLine(argumentList, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(argumentList.SyntaxTree);
+
+        ArgumentListSyntax newNode = ToMultiLine(argumentList, configOptions, cancellationToken);
 
         return document.ReplaceNodeAsync(argumentList, newNode, cancellationToken);
     }
 
-    public static ArgumentListSyntax ToMultiLine(ArgumentListSyntax argumentList, CancellationToken cancellationToken = default)
+    public static ArgumentListSyntax ToMultiLine(ArgumentListSyntax argumentList, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(argumentList, cancellationToken);
+        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(argumentList, configOptions, cancellationToken);
 
         var nodesAndTokens = new List<SyntaxNodeOrToken>();
 
@@ -388,7 +399,9 @@ public static Task<Document> WrapCallChainAsync(
         SemanticModel semanticModel,
         CancellationToken cancellationToken = default)
     {
-        IndentationAnalysis indentationAnalysis = AnalyzeIndentation(expression, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(expression.SyntaxTree);
+
+        IndentationAnalysis indentationAnalysis = AnalyzeIndentation(expression, configOptions, cancellationToken);
 
         string indentation = Environment.NewLine + indentationAnalysis.GetIncreasedIndentation();
 
@@ -457,14 +470,16 @@ public static Task<Document> WrapArgumentsAsync(
         AttributeArgumentListSyntax argumentList,
         CancellationToken cancellationToken = default)
     {
-        AttributeArgumentListSyntax newNode = ToMultiLine(argumentList, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(argumentList.SyntaxTree);
+
+        AttributeArgumentListSyntax newNode = ToMultiLine(argumentList, configOptions, cancellationToken);
 
         return document.ReplaceNodeAsync(argumentList, newNode, cancellationToken);
     }
 
-    private static AttributeArgumentListSyntax ToMultiLine(AttributeArgumentListSyntax argumentList, CancellationToken cancellationToken = default)
+    private static AttributeArgumentListSyntax ToMultiLine(AttributeArgumentListSyntax argumentList, AnalyzerConfigOptions configOptions, CancellationToken cancellationToken = default)
     {
-        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(argumentList, cancellationToken);
+        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(argumentList, configOptions, cancellationToken);
 
         var nodesAndTokens = new List<SyntaxNodeOrToken>();
 
@@ -499,7 +514,9 @@ public static Task<Document> WrapBinaryExpressionAsync(
         BinaryExpressionSyntax condition,
         CancellationToken cancellationToken = default)
     {
-        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(condition, cancellationToken);
+        AnalyzerConfigOptions configOptions = document.GetConfigOptions(condition.SyntaxTree);
+
+        SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(condition, configOptions, cancellationToken);
 
         leadingTrivia = leadingTrivia.Insert(0, DetermineEndOfLine(condition));
 
diff --git a/src/Workspaces.Common/CommonWorkspaceExtensions.cs b/src/Workspaces.Common/CommonWorkspaceExtensions.cs
index 6e425f6114..0dd0f6b58a 100644
--- a/src/Workspaces.Common/CommonWorkspaceExtensions.cs
+++ b/src/Workspaces.Common/CommonWorkspaceExtensions.cs
@@ -1,7 +1,9 @@
 // Copyright (c) Josef Pihrt and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Roslynator.CSharp;
 
 namespace Roslynator;
 
@@ -49,4 +51,9 @@ internal static AnalyzerConfigOptions GetConfigOptions(this Document document, S
     {
         return document.Project.AnalyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree);
     }
+
+    internal static IndentationAnalysis AnalyzeIndentation(this Document document, SyntaxNode node, CancellationToken cancellationToken = default)
+    {
+        return IndentationAnalysis.Create(node, document.GetConfigOptions(node.SyntaxTree), cancellationToken);
+    }
 }