Update indentation code fix provider to adjust an entire element

This change allows for for accurate indentation adjustments of single
code elements which span multiple lines. Since the fix all provider has
not been updated to account for the new behavior, it is disabled for now.

Author: sharwell

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

@@ -3,6 +3,7 @@
 
 namespace StyleCop.Analyzers.Helpers
 {
+    using System.Text;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Settings.ObjectModel;
@@ -83,6 +84,42 @@ public static string GenerateIndentationStringForSteps(IndentationSettings inden
             return result;
         }
 
+        /// <summary>
+        /// Generate a new indentation string for the given indentation width.
+        /// </summary>
+        /// <param name="indentationSettings">The indentation settings to use.</param>
+        /// <param name="indentationWidth">The width of the indentation string.</param>
+        /// <returns>A string containing the whitespace needed to indent code to the specified width.</returns>
+        public static string GenerateIndentationString(IndentationSettings indentationSettings, int indentationWidth) =>
+            GenerateIndentationString(indentationSettings, indentationWidth, 0);
+
+        /// <summary>
+        /// Generate a new indentation string for the given indentation width.
+        /// </summary>
+        /// <param name="indentationSettings">The indentation settings to use.</param>
+        /// <param name="indentationWidth">The width of the indentation string.</param>
+        /// <param name="startColumn">The starting column for the indentation.</param>
+        /// <returns>A string containing the whitespace needed to indent code to the specified width.</returns>
+        public static string GenerateIndentationString(IndentationSettings indentationSettings, int indentationWidth, int startColumn)
+        {
+            if (!indentationSettings.UseTabs)
+            {
+                return new string(' ', indentationWidth);
+            }
+
+            // Adjust the indentation width so a narrower first tab doesn't affect the outcome
+            indentationWidth += startColumn % indentationSettings.TabSize;
+
+            int tabCount = indentationWidth / indentationSettings.TabSize;
+            int spaceCount = indentationWidth - (tabCount * indentationSettings.TabSize);
+
+            StringBuilder builder = StringBuilderPool.Allocate();
+            builder.EnsureCapacity(tabCount + spaceCount);
+            builder.Append('\t', tabCount);
+            builder.Append(' ', spaceCount);
+            return StringBuilderPool.ReturnAndFree(builder);
+        }
+
         /// <summary>
         /// Generates a whitespace trivia with the requested indentation.
         /// </summary>

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/IndentationCodeFixProvider.cs

@@ -12,7 +12,9 @@ namespace StyleCop.Analyzers.ReadabilityRules
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CodeActions;
     using Microsoft.CodeAnalysis.CodeFixes;
+    using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.Text;
+    using Settings.ObjectModel;
 
     [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(IndentationCodeFixProvider))]
     [Shared]
@@ -26,7 +28,7 @@ internal class IndentationCodeFixProvider : CodeFixProvider
 
         /// <inheritdoc/>
         public sealed override FixAllProvider GetFixAllProvider() =>
-            FixAll.Instance;
+            null;
 
         /// <inheritdoc/>
         public override Task RegisterCodeFixesAsync(CodeFixContext context)
@@ -48,26 +50,28 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
         {
             var syntaxRoot = await document.GetSyntaxRootAsync().ConfigureAwait(false);
 
-            TextChange textChange;
-            if (!TryGetTextChange(diagnostic, syntaxRoot, out textChange))
+            StyleCopSettings settings = SettingsHelper.GetStyleCopSettings(document.Project.AnalyzerOptions, cancellationToken);
+            ImmutableArray<TextChange> textChanges = await GetTextChangesAsync(diagnostic, syntaxRoot, settings.Indentation, cancellationToken).ConfigureAwait(false);
+            if (textChanges.IsEmpty)
             {
                 return document;
             }
 
             var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-            return document.WithText(text.WithChanges(textChange));
+            return document.WithText(text.WithChanges(textChanges));
         }
 
-        private static bool TryGetTextChange(Diagnostic diagnostic, SyntaxNode syntaxRoot, out TextChange textChange)
+        private static async Task<ImmutableArray<TextChange>> GetTextChangesAsync(Diagnostic diagnostic, SyntaxNode syntaxRoot, IndentationSettings indentationSettings, CancellationToken cancellationToken)
         {
             string replacement;
             if (!diagnostic.Properties.TryGetValue(SA1137ElementsShouldHaveTheSameIndentation.ExpectedIndentationKey, out replacement))
             {
-                textChange = default(TextChange);
-                return false;
+                return ImmutableArray<TextChange>.Empty;
             }
 
-            var trivia = syntaxRoot.FindTrivia(diagnostic.Location.SourceSpan.Start);
+            SyntaxTrivia trivia = syntaxRoot.FindTrivia(diagnostic.Location.SourceSpan.Start);
+            SyntaxToken token = trivia != default(SyntaxTrivia) ? trivia.Token : syntaxRoot.FindToken(diagnostic.Location.SourceSpan.Start, findInsideTrivia: true);
+            SyntaxNode node = GetNodeForAdjustment(token);
 
             TextSpan originalSpan;
             if (trivia == default(SyntaxTrivia))
@@ -80,8 +84,139 @@ private static bool TryGetTextChange(Diagnostic diagnostic, SyntaxNode syntaxRoo
                 originalSpan = trivia.Span;
             }
 
-            textChange = new TextChange(originalSpan, replacement);
-            return true;
+            FileLinePositionSpan fullSpan = syntaxRoot.SyntaxTree.GetLineSpan(node.FullSpan, cancellationToken);
+            if (fullSpan.StartLinePosition.Line == fullSpan.EndLinePosition.Line)
+            {
+                return ImmutableArray.Create(new TextChange(originalSpan, replacement));
+            }
+
+            SyntaxTree tree = node.SyntaxTree;
+            SourceText sourceText = await tree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+
+            int originalIndentation = GetIndentationWidth(indentationSettings, sourceText.ToString(originalSpan));
+            int newIndentation = GetIndentationWidth(indentationSettings, replacement);
+
+            ImmutableArray<TextSpan> excludedSpans = SyntaxTreeHelpers.GetExcludedSpans(node);
+            TextLineCollection lines = sourceText.Lines;
+
+            // For each line in the full span of the syntax node:
+            // 1. If the line is indented less than originalIndentation, ignore the line
+            // 2. If the indentation characters are not located within the full span, ignore the line
+            // 2. If the indentation characters of the line overlap with an excluded span, ignore the line
+            // 3. Replace the first original.Length characters on the line with replacement
+            ImmutableArray<TextChange>.Builder builder = ImmutableArray.CreateBuilder<TextChange>();
+            for (int i = fullSpan.StartLinePosition.Line; i <= fullSpan.EndLinePosition.Line; i++)
+            {
+                TextLine line = lines[i];
+                string lineText = sourceText.ToString(line.Span);
+
+                int indentationCount;
+                int indentationWidth = GetIndentationWidth(indentationSettings, lineText, out indentationCount);
+                if (indentationWidth < originalIndentation)
+                {
+                    continue;
+                }
+
+                if (indentationCount == line.Span.Length)
+                {
+                    // The line is just whitespace
+                    continue;
+                }
+
+                TextSpan indentationSpan = new TextSpan(line.Start, indentationCount);
+                if (indentationSpan.Start >= node.FullSpan.End)
+                {
+                    // The line does not contain any non-whitespace content which is part of the full span of the node
+                    continue;
+                }
+
+                if (!node.FullSpan.Contains(indentationSpan))
+                {
+                    // The indentation of the line is not part of the full span of the node
+                    continue;
+                }
+
+                if (IsExcluded(excludedSpans, indentationSpan))
+                {
+                    // The line indentation is partially- or fully-excluded from adjustments
+                    continue;
+                }
+
+                if (originalIndentation == indentationWidth)
+                {
+                    builder.Add(new TextChange(indentationSpan, replacement));
+                }
+                else if (newIndentation > originalIndentation)
+                {
+                    // TODO: This needs to handle UseTabs setting
+                    builder.Add(new TextChange(new TextSpan(indentationSpan.End, 0), new string(' ', newIndentation - originalIndentation)));
+                }
+                else if (newIndentation < originalIndentation)
+                {
+                    builder.Add(new TextChange(indentationSpan, IndentationHelper.GenerateIndentationString(indentationSettings, indentationWidth + (newIndentation - originalIndentation))));
+                }
+            }
+
+            return builder.ToImmutable();
+        }
+
+        private static SyntaxNode GetNodeForAdjustment(SyntaxToken token)
+        {
+            return token.Parent;
+        }
+
+        private static int GetIndentationWidth(IndentationSettings indentationSettings, string text)
+        {
+            int ignored;
+            return GetIndentationWidth(indentationSettings, text, out ignored);
+        }
+
+        private static int GetIndentationWidth(IndentationSettings indentationSettings, string text, out int count)
+        {
+            int tabSize = indentationSettings.TabSize;
+            int indentationWidth = 0;
+            for (int i = 0; i < text.Length; i++)
+            {
+                switch (text[i])
+                {
+                case ' ':
+                    indentationWidth++;
+                    break;
+
+                case '\t':
+                    indentationWidth = tabSize * ((indentationWidth / tabSize) + 1);
+                    break;
+
+                default:
+                    count = i;
+                    return indentationWidth;
+                }
+            }
+
+            count = text.Length;
+            return indentationWidth;
+        }
+
+        private static bool IsExcluded(ImmutableArray<TextSpan> excludedSpans, TextSpan textSpan)
+        {
+            int index = excludedSpans.BinarySearch(textSpan);
+            if (index > 0)
+            {
+                return true;
+            }
+
+            int nextLarger = ~index;
+            if (nextLarger > 0 && excludedSpans[nextLarger - 1].OverlapsWith(textSpan))
+            {
+                return true;
+            }
+
+            if (nextLarger < excludedSpans.Length - 1 && excludedSpans[nextLarger].OverlapsWith(textSpan))
+            {
+                return true;
+            }
+
+            return false;
         }
 
         private class FixAll : DocumentBasedFixAllProvider
@@ -100,16 +235,13 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
                 }
 
                 var syntaxRoot = await document.GetSyntaxRootAsync().ConfigureAwait(false);
+                StyleCopSettings settings = SettingsHelper.GetStyleCopSettings(document.Project.AnalyzerOptions, fixAllContext.CancellationToken);
 
                 List<TextChange> changes = new List<TextChange>();
 
                 foreach (var diagnostic in diagnostics)
                 {
-                    TextChange textChange;
-                    if (TryGetTextChange(diagnostic, syntaxRoot, out textChange))
-                    {
-                        changes.Add(textChange);
-                    }
+                    changes.AddRange(await GetTextChangesAsync(diagnostic, syntaxRoot, settings.Indentation, fixAllContext.CancellationToken).ConfigureAwait(false));
                 }
 
                 changes.Sort((left, right) => left.Span.Start.CompareTo(right.Span.Start));

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1137UnitTests.cs

@@ -331,37 +331,37 @@ class MyAttribute : Attribute { }
 using System;
 enum Enum1
 {
-  /// <summary>
-  /// Summary.
-  /// </summary>
+    /// <summary>
+    /// Summary.
+    /// </summary>
     [My]
     Element1,
 
-  /// <summary>
-  /// Summary.
-  /// </summary>
+    /// <summary>
+    /// Summary.
+    /// </summary>
     Element2,
 }
 
 enum Enum2
 {
-  /// <summary>
-  /// Summary.
-  /// </summary>
+/// <summary>
+/// Summary.
+/// </summary>
 [My]
 Element1,
 
-  /// <summary>
-  /// Summary.
-  /// </summary>
+/// <summary>
+/// Summary.
+/// </summary>
 Element2,
 }
 
 enum Enum3
 {
-  /// <summary>
-  /// Summary.
-  /// </summary>
+   /// <summary>
+   /// Summary.
+   /// </summary>
    [My] Element1,
 
    /// <summary>
@@ -1396,13 +1396,13 @@ void MethodName()
       label3:
         while (true)
         {
-label4a:
-label4b:
-int x;
+        label4a:
+        label4b:
+        int x;
 
-label5a:
-label5b:
-int y;
+        label5a:
+        label5b:
+        int y;
         }
     }
 }