Move indentation settings to their own section of stylecop.json

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Helpers/IndentationHelper.cs

@@ -5,6 +5,7 @@ namespace StyleCop.Analyzers.Helpers
 {
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
+    using Settings.ObjectModel;
     using StyleCop.Analyzers.Helpers.ObjectPools;
 
     /// <summary>
@@ -39,39 +40,39 @@ public static SyntaxToken GetFirstTokenOnTextLine(SyntaxToken token)
         /// <summary>
         /// Gets the number of steps that the given node is indented.
         /// </summary>
-        /// <param name="indentationOptions">The indentation options to use.</param>
+        /// <param name="indentationSettings">The indentation settings to use.</param>
         /// <param name="node">The node to inspect.</param>
         /// <returns>The number of steps that the node is indented.</returns>
-        public static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxNode node)
+        public static int GetIndentationSteps(IndentationSettings indentationSettings, SyntaxNode node)
         {
-            return GetIndentationSteps(indentationOptions, node.SyntaxTree, node.GetLeadingTrivia());
+            return GetIndentationSteps(indentationSettings, node.SyntaxTree, node.GetLeadingTrivia());
         }
 
         /// <summary>
         /// Gets the number of steps that the given token is indented.
         /// </summary>
-        /// <param name="indentationOptions">The indentation options to use.</param>
+        /// <param name="indentationSettings">The indentation settings to use.</param>
         /// <param name="token">The token to inspect.</param>
         /// <returns>The number of steps that the token is indented.</returns>
-        public static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxToken token)
+        public static int GetIndentationSteps(IndentationSettings indentationSettings, SyntaxToken token)
         {
-            return GetIndentationSteps(indentationOptions, token.SyntaxTree, token.LeadingTrivia);
+            return GetIndentationSteps(indentationSettings, token.SyntaxTree, token.LeadingTrivia);
         }
 
         /// <summary>
         /// Generate a new indentation string.
         /// </summary>
-        /// <param name="indentationOptions">The indentation options to use.</param>
+        /// <param name="indentationSettings">The indentation settings to use.</param>
         /// <param name="indentationSteps">The number of indentation steps.</param>
         /// <returns>A string containing the amount of whitespace needed for the given indentation steps.</returns>
-        public static string GenerateIndentationString(IndentationOptions indentationOptions, int indentationSteps)
+        public static string GenerateIndentationString(IndentationSettings indentationSettings, int indentationSteps)
         {
             string result;
-            var indentationCount = indentationSteps * indentationOptions.IndentationSize;
-            if (indentationOptions.UseTabs)
+            var indentationCount = indentationSteps * indentationSettings.IndentationSize;
+            if (indentationSettings.UseTabs)
             {
-                var tabCount = indentationCount / indentationOptions.TabSize;
-                var spaceCount = indentationCount % indentationOptions.TabSize;
+                var tabCount = indentationCount / indentationSettings.TabSize;
+                var spaceCount = indentationCount % indentationSettings.TabSize;
                 result = new string('\t', tabCount) + new string(' ', spaceCount);
             }
             else
@@ -85,15 +86,15 @@ public static string GenerateIndentationString(IndentationOptions indentationOpt
         /// <summary>
         /// Generates a whitespace trivia with the requested indentation.
         /// </summary>
-        /// <param name="indentationOptions">The indentation options to use.</param>
+        /// <param name="indentationSettings">The indentation settings to use.</param>
         /// <param name="indentationSteps">The amount of indentation steps.</param>
         /// <returns>A <see cref="SyntaxTrivia"/> containing the indentation whitespace.</returns>
-        public static SyntaxTrivia GenerateWhitespaceTrivia(IndentationOptions indentationOptions, int indentationSteps)
+        public static SyntaxTrivia GenerateWhitespaceTrivia(IndentationSettings indentationSettings, int indentationSteps)
         {
-            return SyntaxFactory.Whitespace(GenerateIndentationString(indentationOptions, indentationSteps));
+            return SyntaxFactory.Whitespace(GenerateIndentationString(indentationSettings, indentationSteps));
         }
 
-        private static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxTree syntaxTree, SyntaxTriviaList leadingTrivia)
+        private static int GetIndentationSteps(IndentationSettings indentationSettings, SyntaxTree syntaxTree, SyntaxTriviaList leadingTrivia)
         {
             var triviaSpan = syntaxTree.GetLineSpan(leadingTrivia.FullSpan);
 
@@ -115,7 +116,7 @@ private static int GetIndentationSteps(IndentationOptions indentationOptions, Sy
                 builder.Insert(0, trivia.ToFullString());
             }
 
-            var tabSize = indentationOptions.TabSize;
+            var tabSize = indentationSettings.TabSize;
             var indentationCount = 0;
             for (var i = 0; i < builder.Length; i++)
             {
@@ -124,7 +125,7 @@ private static int GetIndentationSteps(IndentationOptions indentationOptions, Sy
 
             StringBuilderPool.ReturnAndFree(builder);
 
-            return (indentationCount + (indentationOptions.IndentationSize / 2)) / indentationOptions.IndentationSize;
+            return (indentationCount + (indentationSettings.IndentationSize / 2)) / indentationSettings.IndentationSize;
         }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Helpers/IndentationOptions.cs

@@ -6,6 +6,7 @@ namespace StyleCop.Analyzers.Helpers
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Settings.ObjectModel;
 
     /// <summary>
     /// Helper class containing methods for determining query indentation.
@@ -15,38 +16,38 @@ internal static class QueryIndentationHelpers
         /// <summary>
         /// Gets a whitespace trivia containing the proper amount of indentation for new lines in the given query.
         /// </summary>
-        /// <param name="indentationOptions">The indentation options to use.</param>
+        /// <param name="indentationSettings">The indentation settings to use.</param>
         /// <param name="queryExpression">The query expression to determine indentation from.</param>
         /// <returns>A whitespace trivia containing the proper amount of indentation.</returns>
-        internal static SyntaxTrivia GetQueryIndentationTrivia(IndentationOptions indentationOptions, QueryExpressionSyntax queryExpression)
+        internal static SyntaxTrivia GetQueryIndentationTrivia(IndentationSettings indentationSettings, QueryExpressionSyntax queryExpression)
         {
             var firstTokenOnTextLine = IndentationHelper.GetFirstTokenOnTextLine(queryExpression.FromClause.FromKeyword);
-            var indentationSteps = IndentationHelper.GetIndentationSteps(indentationOptions, firstTokenOnTextLine);
+            var indentationSteps = IndentationHelper.GetIndentationSteps(indentationSettings, firstTokenOnTextLine);
 
             // add an extra indentation step when the first from clause is not properly indented yet
             if (!firstTokenOnTextLine.IsKind(SyntaxKind.OpenParenToken) && (firstTokenOnTextLine != queryExpression.FromClause.FromKeyword))
             {
                 indentationSteps++;
             }
 
-            return IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, indentationSteps);
+            return IndentationHelper.GenerateWhitespaceTrivia(indentationSettings, indentationSteps);
         }
 
         /// <summary>
         /// Gets a whitespace trivia containing the proper amount of indentation for new lines in the query of which the given token is a part.
         /// </summary>
-        /// <param name="indentationOptions">The indentation options to use.</param>
+        /// <param name="indentationSettings">The indentation settings to use.</param>
         /// <param name="token">A token within a query expression.</param>
         /// <returns>A whitespace trivia containing the proper amount of indentation.</returns>
-        internal static SyntaxTrivia GetQueryIndentationTrivia(IndentationOptions indentationOptions, SyntaxToken token)
+        internal static SyntaxTrivia GetQueryIndentationTrivia(IndentationSettings indentationSettings, SyntaxToken token)
         {
             var currentNode = token.Parent;
             while (!currentNode.IsKind(SyntaxKind.QueryExpression))
             {
                 currentNode = currentNode.Parent;
             }
 
-            return GetQueryIndentationTrivia(indentationOptions, (QueryExpressionSyntax)currentNode);
+            return GetQueryIndentationTrivia(indentationSettings, (QueryExpressionSyntax)currentNode);
         }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Helpers/QueryIndentationHelpers.cs

@@ -16,6 +16,7 @@ namespace StyleCop.Analyzers.LayoutRules
     using Microsoft.CodeAnalysis.CodeFixes;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.Text;
+    using Settings.ObjectModel;
 
     /// <summary>
     /// Implements a code fix for <see cref="SA1500BracesForMultiLineStatementsMustNotShareLine"/>.
@@ -54,14 +55,15 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
         {
             var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
+            var settings = SettingsHelper.GetStyleCopSettings(document.Project.AnalyzerOptions, cancellationToken);
             var braceToken = syntaxRoot.FindToken(diagnostic.Location.SourceSpan.Start);
-            var tokenReplacements = GenerateBraceFixes(document, ImmutableArray.Create(braceToken), cancellationToken);
+            var tokenReplacements = GenerateBraceFixes(document, settings.Indentation, ImmutableArray.Create(braceToken), cancellationToken);
 
             var newSyntaxRoot = syntaxRoot.ReplaceTokens(tokenReplacements.Keys, (originalToken, rewrittenToken) => tokenReplacements[originalToken]);
             return document.WithSyntaxRoot(newSyntaxRoot);
         }
 
-        private static Dictionary<SyntaxToken, SyntaxToken> GenerateBraceFixes(Document document, ImmutableArray<SyntaxToken> braceTokens, CancellationToken cancellationToken)
+        private static Dictionary<SyntaxToken, SyntaxToken> GenerateBraceFixes(Document document, IndentationSettings indentationSettings, ImmutableArray<SyntaxToken> braceTokens, CancellationToken cancellationToken)
         {
             var tokenReplacements = new Dictionary<SyntaxToken, SyntaxToken>();
 
@@ -70,8 +72,7 @@ private static Dictionary<SyntaxToken, SyntaxToken> GenerateBraceFixes(Document
                 var braceLine = LocationHelpers.GetLineSpan(braceToken).StartLinePosition.Line;
                 var braceReplacementToken = braceToken;
 
-                var indentationOptions = IndentationOptions.FromDocument(document, cancellationToken);
-                var indentationSteps = DetermineIndentationSteps(indentationOptions, braceToken);
+                var indentationSteps = DetermineIndentationSteps(indentationSettings, braceToken);
 
                 var previousToken = braceToken.GetPreviousToken();
                 var nextToken = braceToken.GetNextToken();
@@ -102,7 +103,7 @@ private static Dictionary<SyntaxToken, SyntaxToken> GenerateBraceFixes(Document
                             AddReplacement(tokenReplacements, previousToken, previousToken.WithTrailingTrivia(previousTokenNewTrailingTrivia));
                         }
 
-                        braceReplacementToken = braceReplacementToken.WithLeadingTrivia(IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, indentationSteps));
+                        braceReplacementToken = braceReplacementToken.WithLeadingTrivia(IndentationHelper.GenerateWhitespaceTrivia(indentationSettings, indentationSteps));
                     }
 
                     // Check if we need to apply a fix after the brace
@@ -132,7 +133,7 @@ private static Dictionary<SyntaxToken, SyntaxToken> GenerateBraceFixes(Document
                                 newIndentationSteps = indentationSteps;
                             }
 
-                            AddReplacement(tokenReplacements, nextToken, nextToken.WithLeadingTrivia(IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, newIndentationSteps)));
+                            AddReplacement(tokenReplacements, nextToken, nextToken.WithLeadingTrivia(IndentationHelper.GenerateWhitespaceTrivia(indentationSettings, newIndentationSteps)));
                         }
 
                         braceReplacementToken = braceReplacementToken.WithTrailingTrivia(newTrailingTrivia);
@@ -199,7 +200,7 @@ private static bool IsValidFollowingToken(SyntaxToken nextToken)
             }
         }
 
-        private static int DetermineIndentationSteps(IndentationOptions indentationOptions, SyntaxToken token)
+        private static int DetermineIndentationSteps(IndentationSettings indentationSettings, SyntaxToken token)
         {
             // For a closing brace use the indentation of the corresponding opening brace
             if (token.IsKind(SyntaxKind.CloseBraceToken))
@@ -229,7 +230,7 @@ private static int DetermineIndentationSteps(IndentationOptions indentationOptio
                 token = token.GetPreviousToken();
             }
 
-            return IndentationHelper.GetIndentationSteps(indentationOptions, token);
+            return IndentationHelper.GetIndentationSteps(indentationSettings, token);
         }
 
         private static bool ContainsStartOfLine(SyntaxToken token, int startLine)
@@ -271,7 +272,9 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
                     .OrderBy(token => token.SpanStart)
                     .ToImmutableArray();
 
-                var tokenReplacements = GenerateBraceFixes(document, tokens, fixAllContext.CancellationToken);
+                var settings = SettingsHelper.GetStyleCopSettings(document.Project.AnalyzerOptions, fixAllContext.CancellationToken);
+
+                var tokenReplacements = GenerateBraceFixes(document, settings.Indentation, tokens, fixAllContext.CancellationToken);
 
                 return syntaxRoot.ReplaceTokens(tokenReplacements.Keys, (originalToken, rewrittenToken) => tokenReplacements[originalToken]);
             }