Update SA1305 to handle C# 7 features

* Support variable designators (pattern syntax)
* Test local function parameters

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/NamingRules/SA1305CSharp7UnitTests.cs

@@ -3,9 +3,74 @@
 
 namespace StyleCop.Analyzers.Test.CSharp7.NamingRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
     using StyleCop.Analyzers.Test.NamingRules;
+    using TestHelper;
+    using Xunit;
 
     public class SA1305CSharp7UnitTests : SA1305UnitTests
     {
+        [Fact]
+        public async Task TestInvalidVariableDesignatorNamesAreReportedAsync()
+        {
+            var testCode = @" public class TestClass
+{
+    public void TestMethod()
+    {
+        var (baR, caRe, daRE, fAre) = (1, 2, 3, 4);
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic().WithLocation(5, 14).WithArguments("variable", "baR"),
+                this.CSharpDiagnostic().WithLocation(5, 19).WithArguments("variable", "caRe"),
+                this.CSharpDiagnostic().WithLocation(5, 25).WithArguments("variable", "daRE"),
+                this.CSharpDiagnostic().WithLocation(5, 31).WithArguments("variable", "fAre"),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestParameterInLocalFunctionAsync()
+        {
+            var testCode = @"
+public class TypeName
+{
+    public void MethodName()
+    {
+        void LocalFunction(bool abX)
+        {
+        }
+    }
+}";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic().WithArguments("parameter", "abX").WithLocation(6, 33),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestParameterInNativeClassLocalFunctionAsync()
+        {
+            var testCode = @"
+public class TypeNameNativeMethods
+{
+    public void MethodName()
+    {
+        void LocalFunction(bool abX)
+        {
+        }
+    }
+}";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1305FieldNamesMustNotUseHungarianNotation.cs

@@ -5,14 +5,14 @@ namespace StyleCop.Analyzers.NamingRules
 {
     using System;
     using System.Collections.Immutable;
-    using System.Linq;
     using System.Text.RegularExpressions;
-    using Helpers;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
     using Settings.ObjectModel;
+    using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// The name of a field or variable in C# uses Hungarian notation.
@@ -76,6 +76,7 @@ internal class SA1305FieldNamesMustNotUseHungarianNotation : DiagnosticAnalyzer
         private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> JoinClauseAction = Analyzer.HandleJoinClause;
         private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> JoinIntoClauseAction = Analyzer.HandleJoinIntoClause;
         private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> ForEachStatementAction = Analyzer.HandleForEachStatement;
+        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> SingleVariableDesignationAction = Analyzer.HandleSingleVariableDesignation;
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -96,6 +97,7 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(JoinClauseAction, SyntaxKind.JoinClause);
             context.RegisterSyntaxNodeAction(JoinIntoClauseAction, SyntaxKind.JoinIntoClause);
             context.RegisterSyntaxNodeAction(ForEachStatementAction, SyntaxKind.ForEachStatement);
+            context.RegisterSyntaxNodeAction(SingleVariableDesignationAction, SyntaxKindEx.SingleVariableDesignation);
         }
 
         private static class Analyzer
@@ -189,6 +191,11 @@ public static void HandleForEachStatement(SyntaxNodeAnalysisContext context, Sty
                 CheckIdentifier(context, ((ForEachStatementSyntax)context.Node).Identifier, settings);
             }
 
+            public static void HandleSingleVariableDesignation(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
+            {
+                CheckIdentifier(context, ((SingleVariableDesignationSyntaxWrapper)context.Node).Identifier, settings);
+            }
+
             private static void CheckIdentifier(SyntaxNodeAnalysisContext context, SyntaxToken identifier, StyleCopSettings settings, string declarationType = "variable")
             {
                 if (identifier.IsMissing)