title: Removing and Adding content with Code Fix Provider
body: <p>I had that previous question which was intended to resolved the state of a local variable / parameter. It works fine, I tweak it a little bit and it looks like this now : </p>
  
  <pre><code>using Microsoft.CodeAnalysis;
  using Microsoft.CodeAnalysis.CSharp;
  using Microsoft.CodeAnalysis.CSharp.Syntax;
  using Microsoft.CodeAnalysis.Diagnostics;
  using System.Collections.Immutable;
  using System.Linq;
  
  namespace RefactoringEssentials.CSharp.Diagnostics
  {
      [DiagnosticAnalyzer(LanguageNames.CSharp)]
      public class LocalVariableNotUsedAnalyzer : DiagnosticAnalyzer
      {
          private static readonly DiagnosticDescriptor descriptor = new DiagnosticDescriptor(
              CSharpDiagnosticIDs.LocalVariableNotUsedAnalyzerID,
              GettextCatalog.GetString("Local variable is never used"),
              GettextCatalog.GetString("Local variable is never used"),
              DiagnosticAnalyzerCategories.RedundanciesInDeclarations,
              DiagnosticSeverity.Warning,
              isEnabledByDefault: true,
              helpLinkUri: HelpLink.CreateFor(CSharpDiagnosticIDs.LocalVariableNotUsedAnalyzerID)
          );
  
          public override ImmutableArray&lt;DiagnosticDescriptor&gt; SupportedDiagnostics =&gt; ImmutableArray.Create(descriptor);
  
          public override void Initialize(AnalysisContext context)
          {
              context.RegisterSyntaxNodeAction(
                  (nodeContext) =&gt;
                  {
                      Diagnostic diagnostic;
                      if (TryGetDiagnostic(nodeContext, out diagnostic))
                      {
                          nodeContext.ReportDiagnostic(diagnostic);
                      }
                  },
                  SyntaxKind.LocalDeclarationStatement
              );
          }
  
  
          private static bool TryGetDiagnostic(SyntaxNodeAnalysisContext nodeContext, out Diagnostic diagnostic)
          {
              diagnostic = default(Diagnostic);
              if (nodeContext.IsFromGeneratedCode())
                  return false;
  
              var localDeclarationUnused = nodeContext.Node as LocalDeclarationStatementSyntax;
              var body = localDeclarationUnused?.Parent as BlockSyntax;
              if (body == null)
                  return false;
  
              var dataFlow = nodeContext.SemanticModel.AnalyzeDataFlow(body);
              var variablesDeclared = dataFlow.VariablesDeclared;
              var variablesRead = dataFlow.ReadInside.Union(dataFlow.ReadOutside);
              var unused = variablesDeclared.Except(variablesRead).ToArray();
              if (unused == null)
                  return false;
  
              if (localDeclarationUnused.Declaration == null || !localDeclarationUnused.Declaration.Variables.Any())
                  return false; 
  
              var localDeclarationSymbol = nodeContext.SemanticModel.GetDeclaredSymbol(localDeclarationUnused.Declaration.Variables.FirstOrDefault());
              if (unused.Any())
              {
                  if (unused.Contains(localDeclarationSymbol))
                  {
                      diagnostic = Diagnostic.Create(descriptor, localDeclarationUnused.Declaration.GetLocation());
                      return true;
                  }
              }
              return false;
          }
      }
  }
  </code></pre>
  
  <p>I have build a code fix provider which is working around 40% of the time, when checking the success rate of the NUnit test. Even though I know the code is OK, there seem to be some error on my machine that only arrives when the code fix is being run. I know this because I can debug the analyzer for the tests and each one are fine. </p>
  
  <p>When the code fix provider is being run, I have this error that I can't shake for some reason : "System.ArgumentNullException : Value cannot be null.
  Parameter name : declaration" 
  I have tried debugging the code fix provider, but nothing showed me where that declaration parameter could be located.</p>
  
  <p>Moreover, I am used with code fix providers that need to either replace and remove nodes. But I'm not used to fix an error and add content and I'm wondering how to do such a thing. </p>
  
  <p>Here's my code fix provider which does not take care of adding information at the moment : </p>
  
  <pre><code>using Microsoft.CodeAnalysis;
  using System.Collections.Immutable;
  using System.Diagnostics;
  using Microsoft.CodeAnalysis.CodeFixes;
  using System.Threading.Tasks;
  using System.Linq;
  using Microsoft.CodeAnalysis.CSharp;
  using Microsoft.CodeAnalysis.CSharp.Syntax;
  
  namespace RefactoringEssentials.CSharp.Diagnostics
  {
  
      [ExportCodeFixProvider(LanguageNames.CSharp), System.Composition.Shared]
      public class LocalVariableNotUsedCodeFixProvider : CodeFixProvider
      {
          public override ImmutableArray&lt;string&gt; FixableDiagnosticIds
          {
              get
              {
                  return ImmutableArray.Create(CSharpDiagnosticIDs.LocalVariableNotUsedAnalyzerID);
              }
          }
  
          public override FixAllProvider GetFixAllProvider()
          {
              return WellKnownFixAllProviders.BatchFixer;
          }
  
          public async override Task RegisterCodeFixesAsync(CodeFixContext context)
          {
              var document = context.Document;
              var cancellationToken = context.CancellationToken;
              var span = context.Span;
              var diagnostics = context.Diagnostics;
              var root = await document.GetSyntaxRootAsync(cancellationToken);
              var diagnostic = diagnostics.First();
              var node = root.FindNode(context.Span);
              if (node == null)
                  return;
              var newRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
              context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove unused local variable", document.WithSyntaxRoot(newRoot)), diagnostic);
          }
      }
  }
  </code></pre>
  
  <p>and here are the tests that I'm using to make sure that the fix is ok. The last two are running just fine :-)</p>
  
  <pre><code>using NUnit.Framework;
  using RefactoringEssentials.CSharp.Diagnostics;
  
  namespace RefactoringEssentials.Tests.CSharp.Diagnostics
  {
      [TestFixture]
      public class LocalVariableNotUsedTests : CSharpDiagnosticTestBase
      {
          [Test]
          public void TestUnusedVariable()
          {
              var input = @"
  class TestClass {
      void TestMethod ()
      {
          $int i$;
      }
  }";
              var output = @"
  class TestClass {
      void TestMethod ()
      {
      }
  }";
              Analyze&lt;LocalVariableNotUsedAnalyzer&gt;(input, output);
          }
  
          [Test]
          public void TestUnusedVariable2()
          {
              var input2 = @"
  class TestClass {
      void TestMethod ()
      {
          $int i, j$;
          j = 1;
      }
  }";
              var output2 = @"
  class TestClass {
      void TestMethod ()
      {
          int j;
          j = 1;
      }
  }";
              Analyze&lt;LocalVariableNotUsedAnalyzer&gt;(input2, output2);
          }
  
          [Test]
          public void TestUsedVariable()
          {
              var input1 = @"
  class TestClass {
      void TestMethod ()
      {
          $int i = 0$;
      }
  }";
              var input2 = @"
  class TestClass {
      void TestMethod ()
      {
          int i;
          i = 0;
      }
  }";
              Analyze&lt;LocalVariableNotUsedAnalyzer&gt;(input1);
              Analyze&lt;LocalVariableNotUsedAnalyzer&gt;(input2);
          }
  
          [Test]
          public void TestUnusedForeachVariable()
          {
              var input = @"
  class TestClass {
      void TestMethod ()
      {
          var array = new int[10];
          foreach (var i in array) {
          }
      }
  }";
              Analyze&lt;LocalVariableNotUsedAnalyzer&gt;(input);
          }
  
          [Test]
          public void TestUsedForeachVariable()
          {
              var input = @"
  class TestClass {
      void TestMethod ()
      {
          var array = new int[10];
          int j = 0;
          foreach (var i in array) {
              j += i;
          }
      }
  }";
              Analyze&lt;LocalVariableNotUsedAnalyzer&gt;(input);
          }
      }
  }
  </code></pre>
  
  <p>Is there is anything that is not clear, I will make sure to update my thread appropriately.</p>