Delay retrieving the SemanticModel element

Getting the SemanticModel instance is potentially an expensive
operation.  For example in the Roslyn.sln project it takes on average
3-5 seconds if it requires creating a new Compilation.  This is true
even when processing a single project because MSBuild will load the
entire solution for such a request and hence the Compilation encompasses
the entire solution.

Delaying access in this manner significantly speeds up the formatting
speed of documents that need no changes.

Author: jaredpar

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

@@ -16,18 +16,19 @@ public sealed class ExplicitThisRule : IFormattingRule
     {
         private sealed class ExplicitThisRewriter : CSharpSyntaxRewriter
         {
-            private readonly SemanticModel _semanticModel;
+            private readonly Document _document;
             private readonly CancellationToken _cancellationToken;
+            private SemanticModel _semanticModel;
             private bool _addedAnnotations;
 
             internal bool AddedAnnotations
             {
                 get { return _addedAnnotations; }
             }
 
-            internal ExplicitThisRewriter(SemanticModel semanticModel, CancellationToken cancellationToken)
+            internal ExplicitThisRewriter(Document document, CancellationToken cancellationToken)
             {
-                _semanticModel = semanticModel;
+                _document = document;
                 _cancellationToken = cancellationToken;
             }
 
@@ -37,22 +38,32 @@ public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyn
                 var name = node.Name.Identifier.ValueText;
                 if (node.Expression != null &&
                     node.Expression.CSharpKind() == SyntaxKind.ThisExpression &&
-                    name.StartsWith("_", StringComparison.Ordinal))
+                    name.StartsWith("_", StringComparison.Ordinal) &&
+                    IsPrivateField(node))
                 {
-                    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)
-                        {
-                            _addedAnnotations = true;
-                            return node.WithAdditionalAnnotations(Simplifier.Annotation);
-                        }
-                    }
+                    _addedAnnotations = true;
+                    return node.WithAdditionalAnnotations(Simplifier.Annotation);
                 }
 
                 return node;
             }
+
+            private bool IsPrivateField(MemberAccessExpressionSyntax memberSyntax)
+            {
+                if (_semanticModel == null)
+                {
+                    _semanticModel = _document.GetSemanticModelAsync(_cancellationToken).Result;
+                }
+
+                var symbolInfo = _semanticModel.GetSymbolInfo(memberSyntax, _cancellationToken);
+                if (symbolInfo.Symbol != null && symbolInfo.Symbol.Kind == SymbolKind.Field)
+                {
+                    var field = (IFieldSymbol)symbolInfo.Symbol;
+                    return field.DeclaredAccessibility == Accessibility.Private;
+                }
+
+                return false;
+            }
         }
 
         public async Task<Document> ProcessAsync(Document document, CancellationToken cancellationToken)
@@ -63,8 +74,7 @@ public async Task<Document> ProcessAsync(Document document, CancellationToken ca
                 return document;
             }
 
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
-            var rewriter = new ExplicitThisRewriter(semanticModel, cancellationToken);
+            var rewriter = new ExplicitThisRewriter(document, cancellationToken);
             var newNode = rewriter.Visit(syntaxNode);
             if (!rewriter.AddedAnnotations)
             {