Simple this removal support

This change supports very simple removal of explicit 'this.' usage.  It
does so when applied to private fields which match the naming
guidelines.

There is still some work to do here with preserving trivia but overall
the rule is functional.

Author: jaredpar

src/Microsoft.DotNet.CodeFormatting.Tests/Microsoft.DotNet.CodeFormatting.Tests.csproj

@@ -105,6 +105,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CodeFormattingTestBase.cs" />
+    <Compile Include="Rules\ExplicitThisRuleTests.cs" />
     <Compile Include="Rules\ExplicitVisibilityRuleTests.cs" />
     <Compile Include="Rules\HasNewLineBeforeFirstNamespaceFormattingRuleTests.cs" />
     <Compile Include="Rules\HasNoIllegalHeadersFormattingRuleTests.cs" />

src/Microsoft.DotNet.CodeFormatting.Tests/Rules/ExplicitThisRuleTests.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Microsoft.DotNet.CodeFormatting.Tests
+{
+    public sealed class ExplicitThisRuleTests : CodeFormattingTestBase
+    {
+        internal override IFormattingRule GetFormattingRule()
+        {
+            return new Rules.ExplicitThisRule();
+        }
+
+        [Fact]
+        public void TestFieldUse()
+        {
+            var text = @"
+class C1
+{
+    int _field1;
+    string _field2;
+    string field3;
+
+    void Use(int i) { } 
+
+    void M()
+    {
+        Use(_field1);
+        Use(_field2);
+        Use(field3);
+        Use(this._field1);
+        Use(this._field2);
+        Use(this.field3);
+    }
+}
+";
+
+            var expected = @"
+class C1
+{
+    int _field1;
+    string _field2;
+    string field3;
+
+    void Use(int i) { } 
+
+    void M()
+    {
+        Use(_field1);
+        Use(_field2);
+        Use(field3);
+        Use(_field1);
+        Use(_field2);
+        Use(this.field3);
+    }
+}
+";
+            Verify(text, expected, runFormatter: false);
+        }
+
+        [Fact]
+        public void TestFieldAssignment()
+        {
+            var text = @"
+class C1
+{
+    int _field1;
+    string _field2;
+    string field3;
+
+    void M()
+    {
+        this._field1 = 0;
+        this._field2 = null;
+        this.field3 = null;
+    }
+}
+";
+
+            var expected = @"
+class C1
+{
+    int _field1;
+    string _field2;
+    string field3;
+
+    void M()
+    {
+        _field1 = 0;
+        _field2 = null;
+        this.field3 = null;
+    }
+}
+";
+            Verify(text, expected, runFormatter: false);
+        }
+    }
+}

src/Microsoft.DotNet.CodeFormatting/Microsoft.DotNet.CodeFormatting.csproj

@@ -94,6 +94,7 @@
     <Compile Include="Rules\IsFormattedFormattingRule.cs" />
     <Compile Include="Rules\IsSimplifiedFormattingRule.cs" />
     <Compile Include="Rules\NonAsciiCharactersAreEscapedInLiteralsRule.cs" />
+    <Compile Include="Rules\ExplicitThisRule.cs" />
     <Compile Include="Rules\RuleExtensions.cs" />
     <Compile Include="Rules\RuleOrder.cs" />
     <Compile Include="Rules\UsesXunitForTestsFormattingRule.cs" />

src/Microsoft.DotNet.CodeFormatting/Rules/ExplicitThisRule.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Microsoft.DotNet.CodeFormatting.Rules
+{
+    [RuleOrder(RuleOrder.RemoveExplicitThisRule)]
+    public sealed class ExplicitThisRule : IFormattingRule
+    {
+        private sealed class ExplicitThisRewriter : CSharpSyntaxRewriter
+        {
+            private readonly SemanticModel _semanticModel;
+            private readonly CancellationToken _cancellationToken;
+
+            internal ExplicitThisRewriter(SemanticModel semanticModel, CancellationToken cancellationToken)
+            {
+                _semanticModel = semanticModel;
+            }
+
+            public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
+            {
+                node = (MemberAccessExpressionSyntax)base.VisitMemberAccessExpression(node);
+                var name = node.Name.Identifier.ValueText;
+                if (node.Expression != null &&
+                    node.Expression.CSharpKind() == SyntaxKind.ThisExpression &&
+                    name.StartsWith("_", StringComparison.Ordinal))
+                {
+                    var symbolInfo = _semanticModel.GetSymbolInfo(node, _cancellationToken);
+                    if (symbolInfo.Symbol != null && symbolInfo.Symbol.Kind == SymbolKind.Field)
+                    {
+                        var field = (IFieldSymbol)symbolInfo.Symbol;
+                        if (field.DeclaredAccessibility == Accessibility.Private)
+                        {
+                            return node.Name
+                                .WithLeadingTrivia(node.GetLeadingTrivia())
+                                .WithTrailingTrivia(node.GetTrailingTrivia());
+                        }
+                    }
+                }
+
+                return node;
+            }
+
+            public override SyntaxNode VisitAssignmentExpression(AssignmentExpressionSyntax node)
+            {
+                return base.VisitAssignmentExpression(node);
+            }
+        }
+
+        public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
+        {
+            var syntaxNode = await document.GetSyntaxRootAsync(cancellationToken) as CSharpSyntaxNode;
+            if (syntaxNode == null)
+            {
+                return document;
+            }
+
+            var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
+            var rewriter = new ExplicitThisRewriter(semanticModel, cancellationToken);
+            var newNode = rewriter.Visit(syntaxNode);
+            return document.WithSyntaxRoot(newNode);
+        }
+    }
+}

src/Microsoft.DotNet.CodeFormatting/Rules/RuleOrder.cs

@@ -25,5 +25,6 @@ internal static class RuleOrder
         public const int IsFormattedFormattingRule = 11;
         public const int UsesXunitForTestsFormattingRule = 12;
         public const int NonAsciiChractersAreEscapedInLiterals = 13;
+        public const int RemoveExplicitThisRule = 14;
     }
 }