Modify SA1100 code fix to operate on BaseExpressionSyntax

Roslyn 2+ didn't recognize our special rewrite where we replaced the text of
the 'base' keyword with 'this'. The new method is slightly slower but ensures
we properly apply code fixes.

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1100CodeFixProvider.cs

@@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.ReadabilityRules
     using Microsoft.CodeAnalysis.CodeActions;
     using Microsoft.CodeAnalysis.CodeFixes;
     using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Text;
 
     /// <summary>
@@ -51,26 +52,22 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
             return SpecializedTasks.CompletedTask;
         }
 
-        private static SyntaxToken GetBaseKeywordToken(SyntaxNode root, TextSpan sourceSpan)
+        private static BaseExpressionSyntax GetBaseExpressionNode(SyntaxNode root, TextSpan sourceSpan)
         {
-            return root.FindToken(sourceSpan.Start);
+            return (BaseExpressionSyntax)root.FindToken(sourceSpan.Start).Parent;
         }
 
-        private static SyntaxToken RewriteBaseAsThis(SyntaxToken token)
+        private static ThisExpressionSyntax RewriteBaseAsThis(BaseExpressionSyntax token)
         {
-            // By creating a `base` token with the literal text `this`, we can replace a token with the code fix instead
-            // of replacing an entire syntax node. This improves the performance of the code fix, but the resulting tree
-            // could be considered in a bad state. However, this is not a problem under any interpretation of the result
-            // because SA1100 is only reported in cases where `base.` and `this.` have the same meaning.
-            return SyntaxFactory.Token(token.LeadingTrivia, SyntaxKind.BaseKeyword, "this", "this", token.TrailingTrivia);
+            return SyntaxFactory.ThisExpression(SyntaxFactory.Token(SyntaxKind.ThisKeyword).WithTriviaFrom(token.Token));
         }
 
         private static async Task<Document> GetTransformedDocumentAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            var token = GetBaseKeywordToken(root, diagnostic.Location.SourceSpan);
+            var node = GetBaseExpressionNode(root, diagnostic.Location.SourceSpan);
 
-            SyntaxNode newSyntaxRoot = root.ReplaceToken(token, RewriteBaseAsThis(token));
+            SyntaxNode newSyntaxRoot = root.ReplaceNode(node, RewriteBaseAsThis(node));
             return document.WithSyntaxRoot(newSyntaxRoot);
         }
 
@@ -91,13 +88,13 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
 
                 var syntaxRoot = await document.GetSyntaxRootAsync().ConfigureAwait(false);
 
-                List<SyntaxToken> tokensToReplace = new List<SyntaxToken>(diagnostics.Length);
+                List<BaseExpressionSyntax> nodesToReplace = new List<BaseExpressionSyntax>(diagnostics.Length);
                 foreach (var diagnostic in diagnostics)
                 {
-                    tokensToReplace.Add(GetBaseKeywordToken(syntaxRoot, diagnostic.Location.SourceSpan));
+                    nodesToReplace.Add(GetBaseExpressionNode(syntaxRoot, diagnostic.Location.SourceSpan));
                 }
 
-                return syntaxRoot.ReplaceTokens(tokensToReplace, (originalToken, rewrittenToken) => RewriteBaseAsThis(rewrittenToken));
+                return syntaxRoot.ReplaceNodes(nodesToReplace, (originalNode, rewrittenNode) => RewriteBaseAsThis(rewrittenNode));
             }
         }
     }