Merge pull request #2422 from sharwell/var-type

Fix analysis of spacing after 'var'

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/SpacingRules/SA1000CSharp7UnitTests.cs

@@ -25,6 +25,24 @@ public async Task TestOutVariableDeclarationAsync()
             await this.TestKeywordStatementAsync(statementWithoutSpace, expected, statementWithSpace).ConfigureAwait(false);
         }
 
+        [Fact]
+        [WorkItem(2419, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2419")]
+        public async Task TestOutVarDiscardAsync()
+        {
+            string statementWithSpace = @"int.TryParse(""0"", out var _);";
+
+            await this.TestKeywordStatementAsync(statementWithSpace, EmptyDiagnosticResults, statementWithSpace).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(2419, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2419")]
+        public async Task TestOutDiscardAsync()
+        {
+            string statementWithSpace = @"int.TryParse(""0"", out _);";
+
+            await this.TestKeywordStatementAsync(statementWithSpace, EmptyDiagnosticResults, statementWithSpace).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestVarKeywordTupleTypeAsync()
         {

StyleCop.Analyzers/StyleCop.Analyzers.Test/SpacingRules/SA1000UnitTests.cs

@@ -646,6 +646,39 @@ public async Task TestNewImplicitArrayStatementAsync()
             await this.TestKeywordStatementAsync(statementWithSpace, EmptyDiagnosticResults, statementWithSpace).ConfigureAwait(false);
         }
 
+        [Fact]
+        [WorkItem(2419, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2419")]
+        public async Task TestVarIdentifierAsync()
+        {
+            string statementWithoutSpace = @"int[] x = null; x.Select(var => var.ToString());";
+
+            string statementWithSpace = @"int[] x = null; x.Select(var => var .ToString());";
+
+            await this.TestKeywordStatementAsync(statementWithoutSpace, EmptyDiagnosticResults, statementWithoutSpace).ConfigureAwait(false);
+
+            // this case is handled by SA1019, so it shouldn't be reported here
+            await this.TestKeywordStatementAsync(statementWithSpace, EmptyDiagnosticResults, statementWithSpace).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that calls on 'var' are handled properly.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        /// <seealso cref="SA1008UnitTests.TestVarIdentifierInvocationAsync"/>
+        [Fact]
+        [WorkItem(2419, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2419")]
+        public async Task TestVarIdentifierInvocationAsync()
+        {
+            string statementWithoutSpace = @"Func<int>[] x = null; x.Select(var => var());";
+
+            string statementWithSpace = @"Func<int>[] x = null; x.Select(var => var ());";
+
+            await this.TestKeywordStatementAsync(statementWithoutSpace, EmptyDiagnosticResults, statementWithoutSpace).ConfigureAwait(false);
+
+            // this case is handled by SA1008, so it shouldn't be reported here
+            await this.TestKeywordStatementAsync(statementWithSpace, EmptyDiagnosticResults, statementWithSpace).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestNewConstructorContraintStatement_TypeAsync()
         {

StyleCop.Analyzers/StyleCop.Analyzers.Test/SpacingRules/SA1008UnitTests.cs

@@ -2011,6 +2011,62 @@ public void Method()
             await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that calls on 'var' are handled properly.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        /// <seealso cref="SA1000UnitTests.TestVarIdentifierInvocationAsync"/>
+        [Fact]
+        [WorkItem(2419, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2419")]
+        public async Task TestVarIdentifierInvocationAsync()
+        {
+            var testCode = @"namespace TestNamespace
+{
+    using System;
+    using System.Linq;
+
+    public class TestClass
+    {
+        public void TestMethod()
+        {
+            Func<int>[] x = null;
+            x.Select(var => var ( ));
+            x.Select(var => var ());
+            x.Select(var => var( ));
+        }
+    }
+}";
+
+            var fixedTestCode = @"namespace TestNamespace
+{
+    using System;
+    using System.Linq;
+
+    public class TestClass
+    {
+        public void TestMethod()
+        {
+            Func<int>[] x = null;
+            x.Select(var => var());
+            x.Select(var => var());
+            x.Select(var => var());
+        }
+    }
+}";
+
+            DiagnosticResult[] expectedDiagnostics =
+            {
+                this.CSharpDiagnostic(DescriptorNotPreceded).WithLocation(11, 33),
+                this.CSharpDiagnostic(DescriptorNotFollowed).WithLocation(11, 33),
+                this.CSharpDiagnostic(DescriptorNotPreceded).WithLocation(12, 33),
+                this.CSharpDiagnostic(DescriptorNotFollowed).WithLocation(13, 32),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expectedDiagnostics, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestMissingTokenAsync()
         {

StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1000KeywordsMustBeSpacedCorrectly.cs

@@ -187,9 +187,33 @@ private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context
 
         private static void HandleIdentifierName(SyntaxNodeAnalysisContext context)
         {
-            IdentifierNameSyntax identifierNameSyntax = (IdentifierNameSyntax)context.Node;
+            var identifierNameSyntax = (IdentifierNameSyntax)context.Node;
             if (identifierNameSyntax.IsVar)
             {
+                var nextToken = identifierNameSyntax.Identifier.GetNextToken();
+                switch (nextToken.Kind())
+                {
+                case SyntaxKind.IdentifierToken:
+                case SyntaxKindEx.UnderscoreToken:
+                    // Always check these
+                    break;
+
+                case SyntaxKind.OpenParenToken:
+                    if (nextToken.Parent.IsKind(SyntaxKindEx.ParenthesizedVariableDesignation))
+                    {
+                        // We have something like this:
+                        //   var (x, i) = (a, b);
+                        break;
+                    }
+
+                    // Could be calling a function named 'var'
+                    return;
+
+                default:
+                    // Not something to check
+                    return;
+                }
+
                 HandleRequiredSpaceToken(ref context, identifierNameSyntax.Identifier);
             }
         }