source: misc/tools/PersistenceCodeFix/PersistenceCodeFix/PersistenceCodeFix/Analyzers/ObsoleteStorableConstructor/ObsoleteStorableConstructorFix.cs @ 16475

using System.Collections.Immutable;
using System.Composition;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace PersistenceCodeFix {
  [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(ObsoleteStorableConstructorFix)), Shared]
  public sealed class ObsoleteStorableConstructorFix : CodeFixProvider, IDocumentCodeFixProvider {
    private const string title = "Change StorableConstructor signature";

    public sealed override ImmutableArray<string> FixableDiagnosticIds {
      get { return ImmutableArray.Create(ObsoleteStorableConstructorAnalyzer.DiagnosticId); }
    }

    public sealed override FixAllProvider GetFixAllProvider() {
      return SequentialFixAllProvider.Instance;
    }

    public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) {
      var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

      var diagnostic = context.Diagnostics.First();
      var diagnosticSpan = diagnostic.Location.SourceSpan;
      var ctorSyntax = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<ConstructorDeclarationSyntax>().First();

      context.RegisterCodeFix(
        CodeAction.Create(
          title: title,
          createChangedDocument: c => FixStorableConstructorSignature(context.Document, ctorSyntax, c),
          equivalenceKey: title),
        diagnostic);
    }

    private static async Task<Document> FixStorableConstructorSignature(Document document, ConstructorDeclarationSyntax ctorSyntax, CancellationToken cancellationToken) {
      // create ctor parameters
      var paramList = SyntaxFactory.ParameterList();
      paramList = paramList.AddParameters(
        SyntaxFactory.Parameter(
          SyntaxFactory.Identifier("_"))
            .WithType(SyntaxFactory.ParseTypeName("StorableConstructorFlag")));

      // create new ctor
      var storableCtor = ctorSyntax.WithParameterList(paramList);

      if (ctorSyntax.Initializer != null) {
        // create initializer args
        var initArgs = SyntaxFactory.ArgumentList();
        initArgs = initArgs.AddArguments(
          SyntaxFactory.Argument(
            SyntaxFactory.IdentifierName("_")));

        // create initializer
        var initializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, initArgs);

        storableCtor = storableCtor.WithInitializer(initializer);
      }

      var root = await document.GetSyntaxRootAsync(cancellationToken) as CompilationUnitSyntax;
      var newRoot = root.ReplaceNode(ctorSyntax, storableCtor);

      return document.WithSyntaxRoot(newRoot);
    }

    public Task<Document> FixDocumentAsync(Document document, SyntaxNode node, CancellationToken cancellationToken) {
      return FixStorableConstructorSignature(document, (ConstructorDeclarationSyntax)node, cancellationToken);
    }
  }
}