有条件地在Roslyn Code Fix中添加“using”语句

Question

I'm using the .NET compiler API to write some code analyzers / code fixers in Roslyn. I want the code fix to transform the following code:

string.Format("{0} {1}", A, B)

To

StringExtensions.SafeJoin(" ", A, B)

So far, I have this code:

private async Task<Document> UseJoinAsync(Document document, InvocationExpressionSyntax invocationExpr, CancellationToken cancellationToken)
{
    var argumentList = invocationExpr.ArgumentList;
    var firstArgument = argumentList.Arguments[1];
    var secondArgument = argumentList.Arguments[2];

    var statement =
        InvocationExpression(
                MemberAccessExpression(
                    SyntaxKind.SimpleMemberAccessExpression,
                    IdentifierName("StringExtensions"), // requires using Trilogy.Miscellaneous
                    IdentifierName("SafeJoin")))
            .WithArgumentList(
                ArgumentList(
                    SeparatedList<ArgumentSyntax>(
                        new SyntaxNodeOrToken[]
                        {
                            Argument(
                                LiteralExpression(
                                    SyntaxKind.StringLiteralExpression,
                                    Literal(" "))),
                            Token(SyntaxKind.CommaToken),
                            firstArgument,
                            Token(SyntaxKind.CommaToken),
                            secondArgument
                        }))).WithLeadingTrivia(invocationExpr.GetLeadingTrivia()).WithTrailingTrivia(invocationExpr.GetTrailingTrivia())
            .WithAdditionalAnnotations(Formatter.Annotation);

    var root = await document.GetSyntaxRootAsync(cancellationToken);

    var newRoot = root.ReplaceNode(invocationExpr, statement);

    var newDocument = document.WithSyntaxRoot(newRoot);

    return newDocument;
}

However, I have two outstanding issues:

1) How can I add the required using Trilogy.Miscellaneous to the top of the file.

and

2) How can I detect if the required assembly is referenced by my Project. In this case, if my assembly Trilogy.Common is not referenced I would either not offer the code fix, or I would propose string.Join(" ", A, B) instead of my own SafeJoin implementation.

UPDATE

I've solved #1 by updating my code as follows...

var newRoot = root.ReplaceNode(invocationExpr, statement);

// Iterate through our usings to see if we've got what we need...
if (root?.Usings.Any(u => u.Name.ToString() == "Trilogy.Miscellaneous") == false)
{
    // Create and add the using statement...
    var usingStatement = UsingDirective(QualifiedName(IdentifierName("Trilogy"), IdentifierName("Miscellaneous")));
     newRoot = newRoot.AddUsings(usingStatement);
}

var newDocument = document.WithSyntaxRoot(newRoot);

return newDocument;

Still hoping for some help with item #2.

Answer 1

I ended up adding some code to the RegisterCodeFixesAsync method. I feel like the test for my required assembly is a bit of a hack, so I'll accept a better answer to this question if someone posts one.

   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;

        // Find the type invocation expression identified by the diagnostic.
        var invocationExpr = root.FindToken(
                diagnosticSpan.Start).Parent.AncestorsAndSelf()
            .OfType<InvocationExpressionSyntax>().First();

        // Get the symantec model from the document
        var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);

        // Check for the assembly we need.  I suspect there is a better way...
        var hasAssembly = semanticModel.Compilation.ExternalReferences.Any(er => er.Properties.Kind == MetadataImageKind.Assembly && er.Display.EndsWith("Trilogy.Common.dll"));

        // Register a code action that will invoke the fix, but only
        // if we have the assembly that we need
        if (hasAssembly)
            context.RegisterCodeFix(
                CodeAction.Create(title, c => UseJoinAsync(
                    context.Document, invocationExpr, c), equivalenceKey: title), diagnostic);
    }