Fix that the SA1130 code fix crashes on an invalid event symbol

Author: pdelvo

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1130CodeFixProvider.cs

@@ -38,19 +38,34 @@ public override FixAllProvider GetFixAllProvider()
         }
 
         /// <inheritdoc/>
-        public override Task RegisterCodeFixesAsync(CodeFixContext context)
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
             foreach (var diagnostic in context.Diagnostics)
             {
+                if (!(await CanFixAsync(context, diagnostic).ConfigureAwait(false)))
+                {
+                    continue;
+                }
+
                 context.RegisterCodeFix(
                     CodeAction.Create(
                         ReadabilityResources.SA1130CodeFix,
                         cancellationToken => GetTransformedDocumentAsync(context.Document, diagnostic, cancellationToken),
                         nameof(SA1134CodeFixProvider)),
                     diagnostic);
             }
+        }
+
+        private static async Task<bool> CanFixAsync(CodeFixContext context, Diagnostic diagnostic)
+        {
+            var syntaxRoot = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
+
+            var anonymousMethod = (AnonymousMethodExpressionSyntax)syntaxRoot.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
 
-            return SpecializedTasks.CompletedTask;
+            var newNode = ReplaceWithLambda(semanticModel, anonymousMethod);
+
+            return newNode != null;
         }
 
         private static SyntaxNode ReplaceWithLambda(SemanticModel semanticModel, AnonymousMethodExpressionSyntax anonymousMethod)
@@ -74,7 +89,14 @@ private static SyntaxNode ReplaceWithLambda(SemanticModel semanticModel, Anonymo
 
                 case SyntaxKind.AddAssignmentExpression:
                 case SyntaxKind.SubtractAssignmentExpression:
-                    argumentList = GetAssignmentArgumentList(semanticModel, anonymousMethod);
+                    var list = GetAssignmentArgumentList(semanticModel, anonymousMethod);
+
+                    if (list == null)
+                    {
+                        return null;
+                    }
+
+                    argumentList = list.Value;
                     break;
                 }
 
@@ -155,11 +177,17 @@ private static ImmutableArray<string> GetEqualsArgumentList(SemanticModel semant
             return namedTypeSymbol.DelegateInvokeMethod.Parameters.Select(ps => ps.Name).ToImmutableArray();
         }
 
-        private static ImmutableArray<string> GetAssignmentArgumentList(SemanticModel semanticModel, AnonymousMethodExpressionSyntax anonymousMethod)
+        private static ImmutableArray<string>? GetAssignmentArgumentList(SemanticModel semanticModel, AnonymousMethodExpressionSyntax anonymousMethod)
         {
             var assignmentExpressionSyntax = (AssignmentExpressionSyntax)anonymousMethod.Parent;
 
             var symbol = semanticModel.GetSymbolInfo(assignmentExpressionSyntax.Left);
+
+            if (symbol.Symbol == null)
+            {
+                return null;
+            }
+
             var eventSymbol = (IEventSymbol)symbol.Symbol;
             var namedTypeSymbol = (INamedTypeSymbol)eventSymbol.Type;
             return namedTypeSymbol.DelegateInvokeMethod.Parameters.Select(ps => ps.Name).ToImmutableArray();
@@ -221,7 +249,9 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
 
             var anonymousMethod = (AnonymousMethodExpressionSyntax)syntaxRoot.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
 
-            var newSyntaxRoot = syntaxRoot.ReplaceNode(anonymousMethod, ReplaceWithLambda(semanticModel, anonymousMethod));
+            var newNode = ReplaceWithLambda(semanticModel, anonymousMethod);
+
+            var newSyntaxRoot = syntaxRoot.ReplaceNode(anonymousMethod, newNode);
             var newDocument = document.WithSyntaxRoot(newSyntaxRoot.WithoutFormatting());
 
             return newDocument;
@@ -247,7 +277,17 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
                     nodes.Add(node);
                 }
 
-                return syntaxRoot.ReplaceNodes(nodes, (originalNode, rewrittenNode) => ReplaceWithLambda(semanticModel, rewrittenNode));
+                return syntaxRoot.ReplaceNodes(nodes, (originalNode, rewrittenNode) =>
+                {
+                    var newNode = ReplaceWithLambda(semanticModel, rewrittenNode);
+
+                    if (newNode == null)
+                    {
+                        return rewrittenNode;
+                    }
+
+                    return newNode;
+                });
             }
         }
     }

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1130UnitTests.cs

@@ -683,5 +683,32 @@ public unsafe class TypeName
             var expected = DiagnosticResult.CompilerError("CS1660").WithLocation(7, 29);
             await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
         }
+
+        [Fact]
+        public async Task VerifyThatCodeFixDoesNotCrashOnMissingEventSymbolAsync()
+        {
+            var testCode = @"
+using System;
+
+namespace StyleCopDemo
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            TestEvent -= delegate { Console.WriteLine(""hello""); };
+        }
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic().WithLocation(10, 26),
+                DiagnosticResult.CompilerError("CS0103").WithLocation(10, 13),
+            };
+
+            await VerifyCSharpFixAsync(testCode, expected, testCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }