Implement SX1101 using the speculative semantic model

Thanks to @vweijsters for some of the new tests. 👍

Fixes #1706
Fixes #1707

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SX1101UnitTests.cs

@@ -59,16 +59,20 @@ public void TestMethod2()
             this.TestMethod1();
         }
 
+        var x = this.listeners;
         this.BaseTestEvent += (s, e) => { };
         var listeners = this.TestEvent;
         if (listeners != null)
         {
             listeners(this, null);
         }
+
+        var y = this.listeners;
     }
+
+    public int listeners;
 }
 ";
-
             var fixedTestCode = @"using System;
 
 public class BaseTestClass
@@ -107,13 +111,18 @@ public void TestMethod2()
             TestMethod1();
         }
 
+        var x = this.listeners;
         BaseTestEvent += (s, e) => { };
         var listeners = TestEvent;
         if (listeners != null)
         {
             listeners(this, null);
         }
+
+        var y = this.listeners;
     }
+
+    public int listeners;
 }
 ";
 
@@ -125,8 +134,8 @@ public void TestMethod2()
                 this.CSharpDiagnostic().WithLocation(30, 84),
                 this.CSharpDiagnostic().WithLocation(32, 13),
                 this.CSharpDiagnostic().WithLocation(36, 13),
-                this.CSharpDiagnostic().WithLocation(39, 9),
-                this.CSharpDiagnostic().WithLocation(40, 25)
+                this.CSharpDiagnostic().WithLocation(40, 9),
+                this.CSharpDiagnostic().WithLocation(41, 25)
             };
 
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
@@ -211,6 +220,11 @@ public class TestClass
 {
     private int test;
 
+    public TestClass(int test)
+    {
+        this.test = test;
+    }
+
     public void TestMethod(int test)
     {
         this.test = test;
@@ -221,6 +235,137 @@ public void TestMethod(int test)
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that a necessary field reference prefix will not produce any diagnostics.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyThatNecessaryFieldReferencePrefixWillNotProduceDiagnosticAsync()
+        {
+            var testCode = @"
+public class TestClass
+{
+    private int test;
+
+    public TestClass()
+    {
+        var test = this.test;
+    }
+
+    public void TestMethod()
+    {
+        var test = this.test;
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestExtensionMethodAsync()
+        {
+            var testCode = @"
+class ClassName
+{
+    string P => string.Empty;
+
+    public void Method()
+    {
+        int value = this.P();
+    }
+}
+
+static class ClassNameExtensions
+{
+    public static int P(this ClassName instance) => 3;
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestTypeArgumentCollisionAsync()
+        {
+            var testCode = @"
+class BaseClass
+{
+    protected int Options => 3;
+}
+
+class DerivedClass : BaseClass
+{
+    void Method<Options>()
+    {
+        int options = this.Options;
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestPropertyValueKeywordCollisionAsync()
+        {
+            var testCode = @"
+class ClassName
+{
+    int value;
+
+    int Value
+    {
+        get { return value; }
+        set { this.value = value; }
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestEscapedParameterCollisionAsync()
+        {
+            var testCode = @"
+class ClassName
+{
+    int @object;
+
+    ClassName(int @object)
+    {
+        this.@object = @object;
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestFieldUseBeforeVariableDefinitionAsync()
+        {
+            var testCode = @"
+class ClassName
+{
+    object p;
+
+    object Property
+    {
+        get
+        {
+            if (this.p != null) return this.p;
+            object p = new object();
+            return this.p = p;
+        }
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         /// <inheritdoc/>
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SX1101DoNotPrefixLocalMembersWithThis.cs

@@ -4,7 +4,6 @@
 namespace StyleCop.Analyzers.ReadabilityRules
 {
     using System;
-    using System.Collections.Generic;
     using System.Collections.Immutable;
     using System.Linq;
     using Microsoft.CodeAnalysis;
@@ -47,33 +46,56 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
 
         private static void HandleThisExpression(SyntaxNodeAnalysisContext context)
         {
-            if (context.Node.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression))
+            if (!context.Node.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression))
             {
-                var memberAccessExpression = (MemberAccessExpressionSyntax)context.Node.Parent;
-                var memberName = memberAccessExpression.Name.ToString();
+                return;
+            }
+
+            var memberAccessExpression = (MemberAccessExpressionSyntax)context.Node.Parent;
+            var originalSymbolInfo = context.SemanticModel.GetSymbolInfo(memberAccessExpression, context.CancellationToken);
+            if (originalSymbolInfo.Symbol == null)
+            {
+                return;
+            }
 
-                var parameters = GetMethodParameters(context.Node);
-                if (!parameters.Contains(memberName))
+            SyntaxNode speculationRoot;
+            var annotation = new SyntaxAnnotation();
+            SemanticModel speculativeModel;
+
+            StatementSyntax statement = context.Node.FirstAncestorOrSelf<StatementSyntax>();
+            if (statement != null)
+            {
+                var modifiedStatement = statement.ReplaceNode(memberAccessExpression, memberAccessExpression.Name.WithAdditionalAnnotations(annotation));
+                speculationRoot = modifiedStatement;
+                if (!context.SemanticModel.TryGetSpeculativeSemanticModel(statement.SpanStart, modifiedStatement, out speculativeModel))
                 {
-                    context.ReportDiagnostic(Diagnostic.Create(Descriptor, context.Node.GetLocation()));
+                    return;
                 }
             }
-        }
-
-        private static IList<string> GetMethodParameters(SyntaxNode node)
-        {
-            while ((node != null) && !node.IsKind(SyntaxKind.MethodDeclaration))
+            else
             {
-                node = node.Parent;
+                ArrowExpressionClauseSyntax arrowExpressionClause = context.Node.FirstAncestorOrSelf<ArrowExpressionClauseSyntax>();
+                if (arrowExpressionClause == null)
+                {
+                    return;
+                }
+
+                var modifiedArrowExpressionClause = arrowExpressionClause.ReplaceNode(memberAccessExpression, memberAccessExpression.Name.WithAdditionalAnnotations(annotation));
+                speculationRoot = modifiedArrowExpressionClause;
+                if (!context.SemanticModel.TryGetSpeculativeSemanticModel(arrowExpressionClause.SpanStart, modifiedArrowExpressionClause, out speculativeModel))
+                {
+                    return;
+                }
             }
 
-            if (node == null)
+            SyntaxNode mappedNode = speculationRoot.GetAnnotatedNodes(annotation).Single();
+            var newSymbolInfo = speculativeModel.GetSymbolInfo(mappedNode, context.CancellationToken);
+            if (!Equals(originalSymbolInfo.Symbol, newSymbolInfo.Symbol))
             {
-                return new List<string>();
+                return;
             }
 
-            var methodDeclaration = (MethodDeclarationSyntax)node;
-            return methodDeclaration.ParameterList.Parameters.Select(p => p.Identifier.ValueText).ToList();
+            context.ReportDiagnostic(Diagnostic.Create(Descriptor, context.Node.GetLocation()));
         }
     }
 }