Simplify duplicated code in SA1000 implementation

sharwell · sharwell · commit b06b16e2a34e · 2017-06-10T21:30:36.000-05:00
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1000KeywordsMustBeSpacedCorrectly.cs b/StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1000KeywordsMustBeSpacedCorrectly.cs
@@ -46,6 +46,13 @@ internal class SA1000KeywordsMustBeSpacedCorrectly : DiagnosticAnalyzer
 
         private static readonly Action<SyntaxTreeAnalysisContext> SyntaxTreeAction = HandleSyntaxTree;
         private static readonly Action<SyntaxNodeAnalysisContext> InvocationExpressionAction = HandleInvocationExpression;
+        private static readonly ReportDiagnosticCallback<SyntaxTreeAnalysisContext> ReportSyntaxTreeDiagnostic =
+            (ref SyntaxTreeAnalysisContext context, Diagnostic diagnostic) => context.ReportDiagnostic(diagnostic);
+
+        private static readonly ReportDiagnosticCallback<SyntaxNodeAnalysisContext> ReportSyntaxNodeDiagnostic =
+            (ref SyntaxNodeAnalysisContext context, Diagnostic diagnostic) => context.ReportDiagnostic(diagnostic);
+
+        private delegate void ReportDiagnosticCallback<TContext>(ref TContext context, Diagnostic diagnostic);
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -93,18 +100,18 @@ private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context)
                 case SyntaxKind.WhereKeyword:
                 case SyntaxKind.WhileKeyword:
                 case SyntaxKind.YieldKeyword:
-                    HandleRequiredSpaceToken(context, token);
+                    HandleRequiredSpaceToken(ref context, token);
                     break;
 
                 case SyntaxKind.CheckedKeyword:
                 case SyntaxKind.UncheckedKeyword:
                     if (token.GetNextToken().IsKind(SyntaxKind.OpenBraceToken))
                     {
-                        HandleRequiredSpaceToken(context, token);
+                        HandleRequiredSpaceToken(ref context, token);
                     }
                     else
                     {
-                        HandleDisallowedSpaceToken(context, token);
+                        HandleDisallowedSpaceToken(ref context, token);
                     }
 
                     break;
@@ -113,19 +120,19 @@ private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context)
                 case SyntaxKind.NameOfKeyword:
                 case SyntaxKind.SizeOfKeyword:
                 case SyntaxKind.TypeOfKeyword:
-                    HandleDisallowedSpaceToken(context, token);
+                    HandleDisallowedSpaceToken(ref context, token);
                     break;
 
                 case SyntaxKind.NewKeyword:
-                    HandleNewKeywordToken(context, token);
+                    HandleNewKeywordToken(ref context, token);
                     break;
 
                 case SyntaxKind.ReturnKeyword:
-                    HandleReturnKeywordToken(context, token);
+                    HandleReturnKeywordToken(ref context, token);
                     break;
 
                 case SyntaxKind.ThrowKeyword:
-                    HandleThrowKeywordToken(context, token);
+                    HandleThrowKeywordToken(ref context, token);
                     break;
 
                 default:
@@ -157,11 +164,14 @@ private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context
             if (constantValue.HasValue && !string.IsNullOrEmpty(constantValue.Value as string))
             {
                 // this is a nameof expression
-                HandleDisallowedSpaceToken(context, identifierNameSyntax.Identifier);
+                HandleDisallowedSpaceToken(ref context, identifierNameSyntax.Identifier);
             }
         }
 
-        private static void HandleRequiredSpaceToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
+        private static void HandleRequiredSpaceToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)
+            => HandleRequiredSpaceToken(ReportSyntaxTreeDiagnostic, ref context, token);
+
+        private static void HandleRequiredSpaceToken<TContext>(ReportDiagnosticCallback<TContext> reportDiagnostic, ref TContext context, SyntaxToken token)
         {
             if (token.IsMissing)
             {
@@ -181,25 +191,16 @@ private static void HandleRequiredSpaceToken(SyntaxTreeAnalysisContext context,
                 }
             }
 
-            context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.InsertFollowing, token.Text, string.Empty));
+            reportDiagnostic(ref context, Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.InsertFollowing, token.Text, string.Empty));
         }
 
-        private static void HandleDisallowedSpaceToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
-        {
-            if (token.IsMissing || !token.HasTrailingTrivia)
-            {
-                return;
-            }
-
-            if (!token.TrailingTrivia.First().IsKind(SyntaxKind.WhitespaceTrivia))
-            {
-                return;
-            }
+        private static void HandleDisallowedSpaceToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)
+            => HandleDisallowedSpaceToken(ReportSyntaxTreeDiagnostic, ref context, token);
 
-            context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.RemoveFollowing, token.Text, " not"));
-        }
+        private static void HandleDisallowedSpaceToken(ref SyntaxNodeAnalysisContext context, SyntaxToken token)
+            => HandleDisallowedSpaceToken(ReportSyntaxNodeDiagnostic, ref context, token);
 
-        private static void HandleDisallowedSpaceToken(SyntaxNodeAnalysisContext context, SyntaxToken token)
+        private static void HandleDisallowedSpaceToken<TContext>(ReportDiagnosticCallback<TContext> reportDiagnostic, ref TContext context, SyntaxToken token)
         {
             if (token.IsMissing || !token.HasTrailingTrivia)
             {
@@ -211,10 +212,10 @@ private static void HandleDisallowedSpaceToken(SyntaxNodeAnalysisContext context
                 return;
             }
 
-            context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.RemoveFollowing, token.Text, " not"));
+            reportDiagnostic(ref context, Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.RemoveFollowing, token.Text, " not"));
         }
 
-        private static void HandleNewKeywordToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
+        private static void HandleNewKeywordToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)
         {
             if (token.IsMissing)
             {
@@ -231,15 +232,15 @@ private static void HandleNewKeywordToken(SyntaxTreeAnalysisContext context, Syn
                     return;
                 }
 
-                HandleDisallowedSpaceToken(context, token);
+                HandleDisallowedSpaceToken(ref context, token);
                 return;
             }
 
             // otherwise treat as required
-            HandleRequiredSpaceToken(context, token);
+            HandleRequiredSpaceToken(ref context, token);
         }
 
-        private static void HandleReturnKeywordToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
+        private static void HandleReturnKeywordToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)
         {
             if (token.IsMissing)
             {
@@ -253,15 +254,15 @@ private static void HandleReturnKeywordToken(SyntaxTreeAnalysisContext context,
             SyntaxToken nextToken = token.GetNextToken();
             if (nextToken.IsKind(SyntaxKind.SemicolonToken) || nextToken.IsKind(SyntaxKind.ColonToken))
             {
-                HandleDisallowedSpaceToken(context, token);
+                HandleDisallowedSpaceToken(ref context, token);
                 return;
             }
 
             // otherwise treat as required
-            HandleRequiredSpaceToken(context, token);
+            HandleRequiredSpaceToken(ref context, token);
         }
 
-        private static void HandleThrowKeywordToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
+        private static void HandleThrowKeywordToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)
         {
             if (token.IsMissing)
             {
@@ -274,12 +275,12 @@ private static void HandleThrowKeywordToken(SyntaxTreeAnalysisContext context, S
             SyntaxToken nextToken = token.GetNextToken();
             if (nextToken.IsKind(SyntaxKind.SemicolonToken))
             {
-                HandleDisallowedSpaceToken(context, token);
+                HandleDisallowedSpaceToken(ref context, token);
                 return;
             }
 
             // otherwise treat as required
-            HandleRequiredSpaceToken(context, token);
+            HandleRequiredSpaceToken(ref context, token);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,13 @@ internal class SA1000KeywordsMustBeSpacedCorrectly : DiagnosticAnalyzer`
`46`	`46`
`47`	`47`	`private static readonly Action<SyntaxTreeAnalysisContext> SyntaxTreeAction = HandleSyntaxTree;`
`48`	`48`	`private static readonly Action<SyntaxNodeAnalysisContext> InvocationExpressionAction = HandleInvocationExpression;`
	`49`	`+ private static readonly ReportDiagnosticCallback<SyntaxTreeAnalysisContext> ReportSyntaxTreeDiagnostic =`
	`50`	`+ (ref SyntaxTreeAnalysisContext context, Diagnostic diagnostic) => context.ReportDiagnostic(diagnostic);`
	`51`	`+`
	`52`	`+ private static readonly ReportDiagnosticCallback<SyntaxNodeAnalysisContext> ReportSyntaxNodeDiagnostic =`
	`53`	`+ (ref SyntaxNodeAnalysisContext context, Diagnostic diagnostic) => context.ReportDiagnostic(diagnostic);`
	`54`	`+`
	`55`	`+ private delegate void ReportDiagnosticCallback<TContext>(ref TContext context, Diagnostic diagnostic);`
`49`	`56`
`50`	`57`	`/// <inheritdoc/>`
`51`	`58`	`public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =`
`@@ -93,18 +100,18 @@ private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context)`
`93`	`100`	`case SyntaxKind.WhereKeyword:`
`94`	`101`	`case SyntaxKind.WhileKeyword:`
`95`	`102`	`case SyntaxKind.YieldKeyword:`
`96`		`- HandleRequiredSpaceToken(context, token);`
	`103`	`+ HandleRequiredSpaceToken(ref context, token);`
`97`	`104`	`break;`
`98`	`105`
`99`	`106`	`case SyntaxKind.CheckedKeyword:`
`100`	`107`	`case SyntaxKind.UncheckedKeyword:`
`101`	`108`	`if (token.GetNextToken().IsKind(SyntaxKind.OpenBraceToken))`
`102`	`109`	`{`
`103`		`- HandleRequiredSpaceToken(context, token);`
	`110`	`+ HandleRequiredSpaceToken(ref context, token);`
`104`	`111`	`}`
`105`	`112`	`else`
`106`	`113`	`{`
`107`		`- HandleDisallowedSpaceToken(context, token);`
	`114`	`+ HandleDisallowedSpaceToken(ref context, token);`
`108`	`115`	`}`
`109`	`116`
`110`	`117`	`break;`
`@@ -113,19 +120,19 @@ private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context)`
`113`	`120`	`case SyntaxKind.NameOfKeyword:`
`114`	`121`	`case SyntaxKind.SizeOfKeyword:`
`115`	`122`	`case SyntaxKind.TypeOfKeyword:`
`116`		`- HandleDisallowedSpaceToken(context, token);`
	`123`	`+ HandleDisallowedSpaceToken(ref context, token);`
`117`	`124`	`break;`
`118`	`125`
`119`	`126`	`case SyntaxKind.NewKeyword:`
`120`		`- HandleNewKeywordToken(context, token);`
	`127`	`+ HandleNewKeywordToken(ref context, token);`
`121`	`128`	`break;`
`122`	`129`
`123`	`130`	`case SyntaxKind.ReturnKeyword:`
`124`		`- HandleReturnKeywordToken(context, token);`
	`131`	`+ HandleReturnKeywordToken(ref context, token);`
`125`	`132`	`break;`
`126`	`133`
`127`	`134`	`case SyntaxKind.ThrowKeyword:`
`128`		`- HandleThrowKeywordToken(context, token);`
	`135`	`+ HandleThrowKeywordToken(ref context, token);`
`129`	`136`	`break;`
`130`	`137`
`131`	`138`	`default:`
`@@ -157,11 +164,14 @@ private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context`
`157`	`164`	`if (constantValue.HasValue && !string.IsNullOrEmpty(constantValue.Value as string))`
`158`	`165`	`{`
`159`	`166`	`// this is a nameof expression`
`160`		`- HandleDisallowedSpaceToken(context, identifierNameSyntax.Identifier);`
	`167`	`+ HandleDisallowedSpaceToken(ref context, identifierNameSyntax.Identifier);`
`161`	`168`	`}`
`162`	`169`	`}`
`163`	`170`
`164`		`- private static void HandleRequiredSpaceToken(SyntaxTreeAnalysisContext context, SyntaxToken token)`
	`171`	`+ private static void HandleRequiredSpaceToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)`
	`172`	`+ => HandleRequiredSpaceToken(ReportSyntaxTreeDiagnostic, ref context, token);`
	`173`	`+`
	`174`	`+ private static void HandleRequiredSpaceToken<TContext>(ReportDiagnosticCallback<TContext> reportDiagnostic, ref TContext context, SyntaxToken token)`
`165`	`175`	`{`
`166`	`176`	`if (token.IsMissing)`
`167`	`177`	`{`
`@@ -181,25 +191,16 @@ private static void HandleRequiredSpaceToken(SyntaxTreeAnalysisContext context,`
`181`	`191`	`}`
`182`	`192`	`}`
`183`	`193`
`184`		`- context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.InsertFollowing, token.Text, string.Empty));`
	`194`	`+ reportDiagnostic(ref context, Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.InsertFollowing, token.Text, string.Empty));`
`185`	`195`	`}`
`186`	`196`
`187`		`- private static void HandleDisallowedSpaceToken(SyntaxTreeAnalysisContext context, SyntaxToken token)`
`188`		`- {`
`189`		`- if (token.IsMissing \|\| !token.HasTrailingTrivia)`
`190`		`- {`
`191`		`- return;`
`192`		`- }`
`193`		`-`
`194`		`- if (!token.TrailingTrivia.First().IsKind(SyntaxKind.WhitespaceTrivia))`
`195`		`- {`
`196`		`- return;`
`197`		`- }`
	`197`	`+ private static void HandleDisallowedSpaceToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)`
	`198`	`+ => HandleDisallowedSpaceToken(ReportSyntaxTreeDiagnostic, ref context, token);`
`198`	`199`
`199`		`- context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.RemoveFollowing, token.Text, " not"));`
`200`		`- }`
	`200`	`+ private static void HandleDisallowedSpaceToken(ref SyntaxNodeAnalysisContext context, SyntaxToken token)`
	`201`	`+ => HandleDisallowedSpaceToken(ReportSyntaxNodeDiagnostic, ref context, token);`
`201`	`202`
`202`		`- private static void HandleDisallowedSpaceToken(SyntaxNodeAnalysisContext context, SyntaxToken token)`
	`203`	`+ private static void HandleDisallowedSpaceToken<TContext>(ReportDiagnosticCallback<TContext> reportDiagnostic, ref TContext context, SyntaxToken token)`
`203`	`204`	`{`
`204`	`205`	`if (token.IsMissing \|\| !token.HasTrailingTrivia)`
`205`	`206`	`{`
`@@ -211,10 +212,10 @@ private static void HandleDisallowedSpaceToken(SyntaxNodeAnalysisContext context`
`211`	`212`	`return;`
`212`	`213`	`}`
`213`	`214`
`214`		`- context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.RemoveFollowing, token.Text, " not"));`
	`215`	`+ reportDiagnostic(ref context, Diagnostic.Create(Descriptor, token.GetLocation(), TokenSpacingProperties.RemoveFollowing, token.Text, " not"));`
`215`	`216`	`}`
`216`	`217`
`217`		`- private static void HandleNewKeywordToken(SyntaxTreeAnalysisContext context, SyntaxToken token)`
	`218`	`+ private static void HandleNewKeywordToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)`
`218`	`219`	`{`
`219`	`220`	`if (token.IsMissing)`
`220`	`221`	`{`
`@@ -231,15 +232,15 @@ private static void HandleNewKeywordToken(SyntaxTreeAnalysisContext context, Syn`
`231`	`232`	`return;`
`232`	`233`	`}`
`233`	`234`
`234`		`- HandleDisallowedSpaceToken(context, token);`
	`235`	`+ HandleDisallowedSpaceToken(ref context, token);`
`235`	`236`	`return;`
`236`	`237`	`}`
`237`	`238`
`238`	`239`	`// otherwise treat as required`
`239`		`- HandleRequiredSpaceToken(context, token);`
	`240`	`+ HandleRequiredSpaceToken(ref context, token);`
`240`	`241`	`}`
`241`	`242`
`242`		`- private static void HandleReturnKeywordToken(SyntaxTreeAnalysisContext context, SyntaxToken token)`
	`243`	`+ private static void HandleReturnKeywordToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)`
`243`	`244`	`{`
`244`	`245`	`if (token.IsMissing)`
`245`	`246`	`{`
`@@ -253,15 +254,15 @@ private static void HandleReturnKeywordToken(SyntaxTreeAnalysisContext context,`
`253`	`254`	`SyntaxToken nextToken = token.GetNextToken();`
`254`	`255`	`if (nextToken.IsKind(SyntaxKind.SemicolonToken) \|\| nextToken.IsKind(SyntaxKind.ColonToken))`
`255`	`256`	`{`
`256`		`- HandleDisallowedSpaceToken(context, token);`
	`257`	`+ HandleDisallowedSpaceToken(ref context, token);`
`257`	`258`	`return;`
`258`	`259`	`}`
`259`	`260`
`260`	`261`	`// otherwise treat as required`
`261`		`- HandleRequiredSpaceToken(context, token);`
	`262`	`+ HandleRequiredSpaceToken(ref context, token);`
`262`	`263`	`}`
`263`	`264`
`264`		`- private static void HandleThrowKeywordToken(SyntaxTreeAnalysisContext context, SyntaxToken token)`
	`265`	`+ private static void HandleThrowKeywordToken(ref SyntaxTreeAnalysisContext context, SyntaxToken token)`
`265`	`266`	`{`
`266`	`267`	`if (token.IsMissing)`
`267`	`268`	`{`
`@@ -274,12 +275,12 @@ private static void HandleThrowKeywordToken(SyntaxTreeAnalysisContext context, S`
`274`	`275`	`SyntaxToken nextToken = token.GetNextToken();`
`275`	`276`	`if (nextToken.IsKind(SyntaxKind.SemicolonToken))`
`276`	`277`	`{`
`277`		`- HandleDisallowedSpaceToken(context, token);`
	`278`	`+ HandleDisallowedSpaceToken(ref context, token);`
`278`	`279`	`return;`
`279`	`280`	`}`
`280`	`281`
`281`	`282`	`// otherwise treat as required`
`282`		`- HandleRequiredSpaceToken(context, token);`
	`283`	`+ HandleRequiredSpaceToken(ref context, token);`
`283`	`284`	`}`
`284`	`285`	`}`
`285`	`286`	`}`