Merge pull request #2758 from jnm2/permit_double_underscore_lambda_param

Allow double underscore as lambda parameter name

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1313UnitTests.cs

@@ -401,8 +401,8 @@ public void MethodName()
         }
 
         [Fact]
-        [WorkItem(1343, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1343")]
-        public async Task TestLambdaParameterMultipleUnderscoresAsync()
+        [WorkItem(1606, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1606")]
+        public async Task TestLambdaParameterNamedDoubleUnderscoreAsync()
         {
             var testCode = @"public class TypeName
 {
@@ -414,11 +414,49 @@ public void MethodName()
     }
 }";
 
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies this diagnostic does not check whether or not a parameter named <c>__</c> is being used.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        [Fact]
+        [WorkItem(1606, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1606")]
+        public async Task TestLambdaParameterNamedDoubleUnderscoreUsageAsync()
+        {
+            var testCode = @"public class TypeName
+{
+    public void MethodName()
+    {
+        System.Func<int, int> function1 = __ => __;
+        System.Func<int, int> function2 = (__) => __;
+        System.Func<int, int> function3 = delegate(int __) { return __; };
+    }
+}";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(1343, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1343")]
+        public async Task TestLambdaParameterWithThreeUnderscoresAsync()
+        {
+            var testCode = @"public class TypeName
+{
+    public void MethodName()
+    {
+        System.Action<int> action1 = ___ => { };
+        System.Action<int> action2 = (___) => { };
+        System.Action<int> action3 = delegate(int ___) { };
+    }
+}";
+
             DiagnosticResult[] expected =
             {
-                this.CSharpDiagnostic().WithArguments("__").WithLocation(5, 38),
-                this.CSharpDiagnostic().WithArguments("__").WithLocation(6, 39),
-                this.CSharpDiagnostic().WithArguments("__").WithLocation(7, 51),
+                this.CSharpDiagnostic().WithArguments("___").WithLocation(5, 38),
+                this.CSharpDiagnostic().WithArguments("___").WithLocation(6, 39),
+                this.CSharpDiagnostic().WithArguments("___").WithLocation(7, 51),
             };
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
             await this.VerifyCSharpFixAsync(testCode, testCode).ConfigureAwait(false);
@@ -439,6 +477,21 @@ public void MethodName(int _)
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        [WorkItem(1606, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1606")]
+        public async Task TestMethodParameterNamedDoubleUnderscoreAsync()
+        {
+            var testCode = @"public class TypeName
+{
+    public void MethodName(int __)
+    {
+    }
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithArguments("__").WithLocation(3, 32);
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         [WorkItem(1529, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/1529")]
         public async Task TestInheritedInterfacesWithOverloadedMembersAsync()

StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1313ParameterNamesMustBeginWithLowerCaseLetter.cs

@@ -17,8 +17,8 @@ namespace StyleCop.Analyzers.NamingRules
     /// <remarks>
     /// <para>A violation of this rule occurs when the name of a parameter does not begin with a lower-case letter.</para>
     ///
-    /// <para>An exception to this rule is made for lambda parameters named <c>_</c>. These parameters are often used to
-    /// designate a placeholder parameter which is not actually used in the body of the lambda expression.</para>
+    /// <para>An exception to this rule is made for lambda parameters named <c>_</c> and <c>__</c>. These parameters are
+    /// often used to designate a placeholder parameter which is not actually used in the body of the lambda expression.</para>
     ///
     /// <para>If the parameter name is intended to match the name of an item associated with Win32 or COM, and thus
     /// needs to begin with an upper-case letter, place the parameter within a special <c>NativeMethods</c> class. A
@@ -76,7 +76,7 @@ private static void HandleParameter(SyntaxNodeAnalysisContext context)
                 return;
             }
 
-            if (name == "_" && IsInLambda(syntax))
+            if ((name == "_" || name == "__") && IsInLambda(syntax))
             {
                 return;
             }

documentation/KnownChanges.md

@@ -199,6 +199,10 @@ This rule is disabled by default in StyleCop Analyzers, but can be enabled by us
 :warning: StyleCop Analyzers does not report SA1305 for parameters in overriding methods and methods which implement an
 interface. StyleCop Classic reported SA1305 for all methods.
 
+### SA1313
+
+StyleCop Analyzers allows the single and double underscore (`_` and `__`) as lambda parameter names.
+
 ## Maintainability Rules
 
 There are no known changes at this time.

documentation/SA1313.md

@@ -25,7 +25,7 @@ The name of a parameter in C# does not begin with a lower-case letter.
 
 A violation of this rule occurs when the name of a parameter does not begin with a lower-case letter.
 
-An exception to this rule is made for lambda parameters named `_`. These parameters are often used to designate a
+An exception to this rule is made for lambda parameters named `_` and `__`. These parameters are often used to designate a
 placeholder parameter which is not actually used in the body of the lambda expression.
 
 If the parameter name is intended to match the name of an item associated with Win32 or COM, and thus needs to begin