Update SA1300 to handle local functions

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Helpers/RenameHelper.cs

@@ -12,6 +12,7 @@ namespace StyleCop.Analyzers.Helpers
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Rename;
+    using StyleCop.Analyzers.Lightup;
 
     internal static class RenameHelper
     {
@@ -158,6 +159,8 @@ public static SyntaxNode GetParentDeclaration(SyntaxToken token)
                 case SyntaxKind.UsingDirective:
                 case SyntaxKind.LabeledStatement:
                 case SyntaxKind.AnonymousObjectMemberDeclarator:
+                case SyntaxKindEx.LocalFunctionStatement:
+                case SyntaxKindEx.SingleVariableDesignation:
                     return parent;
 
                 default:
@@ -191,6 +194,25 @@ public bool Found
                 private set;
             }
 
+            public override void Visit(SyntaxNode node)
+            {
+                switch (node.Kind())
+                {
+                case SyntaxKindEx.LocalFunctionStatement:
+                    this.Found |= ((LocalFunctionStatementSyntaxWrapper)node).Identifier.ValueText == this.name;
+                    break;
+
+                case SyntaxKindEx.SingleVariableDesignation:
+                    this.Found |= ((SingleVariableDesignationSyntaxWrapper)node).Identifier.ValueText == this.name;
+                    break;
+
+                default:
+                    break;
+                }
+
+                base.Visit(node);
+            }
+
             public override void VisitVariableDeclarator(VariableDeclaratorSyntax node)
             {
                 this.Found |= node.Identifier.ValueText == this.name;

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

@@ -3,9 +3,91 @@
 
 namespace StyleCop.Analyzers.Test.CSharp7.NamingRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
     using StyleCop.Analyzers.Test.NamingRules;
+    using TestHelper;
+    using Xunit;
 
     public class SA1300CSharp7UnitTests : SA1300UnitTests
     {
+        [Fact]
+        public async Task TestUpperCaseLocalFunctionAsync()
+        {
+            var testCode = @"public class TestClass
+{
+    public void Method()
+    {
+        void LocalFunction()
+        {
+        }
+    }
+}";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestLowerCaseLocalFunctionAsync()
+        {
+            var testCode = @"public class TestClass
+{
+    public void Method()
+    {
+        void localFunction()
+        {
+        }
+    }
+}";
+            var fixedCode = @"public class TestClass
+{
+    public void Method()
+    {
+        void LocalFunction()
+        {
+        }
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithArguments("localFunction").WithLocation(5, 14);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestLowerCaseLocalFunctionWithConflictAsync()
+        {
+            // Conflict resolution does not attempt to examine overloaded methods.
+            var testCode = @"public class TestClass
+{
+    public void Method()
+    {
+        void localFunction()
+        {
+        }
+
+        int LocalFunction(int value) => value;
+    }
+}";
+            var fixedCode = @"public class TestClass
+{
+    public void Method()
+    {
+        void LocalFunction1()
+        {
+        }
+
+        int LocalFunction(int value) => value;
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithArguments("localFunction").WithLocation(5, 14);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1300ElementMustBeginWithUpperCaseLetter.cs

@@ -11,6 +11,7 @@ namespace StyleCop.Analyzers.NamingRules
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// The name of a C# element does not begin with an upper-case letter.
@@ -53,6 +54,7 @@ internal class SA1300ElementMustBeginWithUpperCaseLetter : DiagnosticAnalyzer
         private static readonly Action<SyntaxNodeAnalysisContext> EventDeclarationAction = HandleEventDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> EventFieldDeclarationAction = HandleEventFieldDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> MethodDeclarationAction = HandleMethodDeclaration;
+        private static readonly Action<SyntaxNodeAnalysisContext> LocalFunctionStatementAction = HandleLocalFunctionStatement;
         private static readonly Action<SyntaxNodeAnalysisContext> PropertyDeclarationAction = HandlePropertyDeclaration;
 
         /// <inheritdoc/>
@@ -76,6 +78,7 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(EventDeclarationAction, SyntaxKind.EventDeclaration);
             context.RegisterSyntaxNodeAction(EventFieldDeclarationAction, SyntaxKind.EventFieldDeclaration);
             context.RegisterSyntaxNodeAction(MethodDeclarationAction, SyntaxKind.MethodDeclaration);
+            context.RegisterSyntaxNodeAction(LocalFunctionStatementAction, SyntaxKindEx.LocalFunctionStatement);
             context.RegisterSyntaxNodeAction(PropertyDeclarationAction, SyntaxKind.PropertyDeclaration);
         }
 
@@ -179,6 +182,12 @@ private static void HandleMethodDeclaration(SyntaxNodeAnalysisContext context)
             CheckElementNameToken(context, methodDeclaration.Identifier);
         }
 
+        private static void HandleLocalFunctionStatement(SyntaxNodeAnalysisContext context)
+        {
+            var localFunctionStatement = (LocalFunctionStatementSyntaxWrapper)context.Node;
+            CheckElementNameToken(context, localFunctionStatement.Identifier);
+        }
+
         private static void HandlePropertyDeclaration(SyntaxNodeAnalysisContext context)
         {
             var propertyDeclaration = (PropertyDeclarationSyntax)context.Node;