Adding support for catch clause variables

Neme12 · Neme12 · commit 09d2e08c653a · 2018-04-24T17:16:37.000+02:00
diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/NamingStylesTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/NamingStyles/NamingStylesTests.cs
@@ -298,6 +298,39 @@ void M()
                 options: options.LocalNamesAreCamelCase);
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)]
+        public async Task TestCamelCaseLocals_CatchVariable()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+class C
+{
+    void M()
+    {
+        try
+        {
+        }
+        catch (Exception [|Exception|])
+        {
+        }
+    }
+}",
+@"using System;
+class C
+{
+    void M()
+    {
+        try
+        {
+        }
+        catch (Exception exception)
+        {
+        }
+    }
+}",
+                options: options.LocalNamesAreCamelCase);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)]
         public async Task TestCamelCaseLocals_Deconstruction1()
         {
diff --git a/src/EditorFeatures/VisualBasicTest/Diagnostics/NamingStyles/NamingStylesTests.vb b/src/EditorFeatures/VisualBasicTest/Diagnostics/NamingStyles/NamingStylesTests.vb
@@ -246,6 +246,28 @@ end module",
                 options:=options.LocalNamesAreCamelCase)
         End Function
 
+        <Fact, Trait(Traits.Feature, Traits.Features.NamingStyle)>
+        Public Async Function TestCamelCaseLocals_CatchVariable() As Task
+            Await TestInRegularAndScriptAsync(
+"imports System
+module C
+    sub M()
+        try
+        catch [|Exception|] as Exception
+        end try
+    end sub
+end module",
+"imports System
+module C
+    sub M()
+        try
+        catch exception as Exception
+        end try
+    end sub
+end module",
+                options:=options.LocalNamesAreCamelCase)
+        End Function
+
         <Fact(Skip:="Implicit declarations cannot be found by syntax. Requires https://github.com/dotnet/roslyn/issues/14061")>
         <Trait(Traits.Feature, Traits.Features.NamingStyle)>
         Public Async Function TestCamelCaseLocals_ImplicitlyDeclaredLocal() As Task
diff --git a/src/Features/CSharp/Portable/Diagnostics/Analyzers/CSharpNamingStyleDiagnosticAnalyzer.cs b/src/Features/CSharp/Portable/Diagnostics/Analyzers/CSharpNamingStyleDiagnosticAnalyzer.cs
@@ -13,6 +13,7 @@ internal sealed class CSharpNamingStyleDiagnosticAnalyzer : NamingStyleDiagnosti
             ImmutableArray.Create(
                 SyntaxKind.VariableDeclarator,
                 SyntaxKind.ForEachStatement,
+                SyntaxKind.CatchDeclaration,
                 SyntaxKind.SingleVariableDesignation);
     }
 }
diff --git a/src/Features/Core/Portable/CodeFixes/NamingStyle/AbstractNamingStyleCodeFixProvider.cs b/src/Features/Core/Portable/CodeFixes/NamingStyle/AbstractNamingStyleCodeFixProvider.cs
@@ -11,8 +11,10 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeActions.WorkspaceServices;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.NamingStyles;
 using Microsoft.CodeAnalysis.Rename;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CodeFixes.NamingStyles
@@ -37,6 +39,17 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
             var root = await document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
             var node = root.FindNode(span);
+
+            if (document.GetLanguageService<ISyntaxFactsService>().IsIdentifierName(node))
+            {
+                // The location we get from the analyzer only contains the identifier token and when we get its containing node,
+                // it is usually the right one (such as a variable declarator, designation or a foreach statement)
+                // because there is no other node in between. But there is one case in a VB catch clause where the token
+                // is wrapped in an identifier name. So if what we found is an identifier, take the parent node instead.
+                // Note that this is the correct thing to do because GetDeclaredSymbol never works on identifier names.
+                node = node.Parent;
+            }
+
             var model = await document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
             var symbol = model.GetDeclaredSymbol(node, context.CancellationToken);
 
diff --git a/src/Features/VisualBasic/Portable/Diagnostics/Analyzers/VisualBasicNamingStyleDiagnosticAnalyzer.vb b/src/Features/VisualBasic/Portable/Diagnostics/Analyzers/VisualBasicNamingStyleDiagnosticAnalyzer.vb
@@ -10,6 +10,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Diagnostics.Analyzers
         Inherits NamingStyleDiagnosticAnalyzerBase(Of SyntaxKind)
 
         Protected Overrides ReadOnly Property SupportedSyntaxKinds As ImmutableArray(Of SyntaxKind) =
-            ImmutableArray.Create(SyntaxKind.ModifiedIdentifier)
+            ImmutableArray.Create(
+                SyntaxKind.ModifiedIdentifier,
+                SyntaxKind.CatchStatement)
     End Class
 End Namespace

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ internal sealed class CSharpNamingStyleDiagnosticAnalyzer : NamingStyleDiagnosti`
`13`	`13`	`ImmutableArray.Create(`
`14`	`14`	`SyntaxKind.VariableDeclarator,`
`15`	`15`	`SyntaxKind.ForEachStatement,`
	`16`	`+ SyntaxKind.CatchDeclaration,`
`16`	`17`	`SyntaxKind.SingleVariableDesignation);`
`17`	`18`	`}`
`18`	`19`	`}`