private bool TryFindInvocation(
            TextSpan span,
            SyntaxNode root,
            SemanticModel semanticModel,
            ImmutableArray <IMethodSymbol> formatMethods,
            ISyntaxFactsService syntaxFactsService,
            CancellationToken cancellationToken,
            out TInvocationExpressionSyntax invocation,
            out ISymbol invocationSymbol)
        {
            invocationSymbol = null;
            invocation       = root.FindNode(span, getInnermostNodeForTie: true)?.FirstAncestorOrSelf <TInvocationExpressionSyntax>();
            while (invocation != null)
            {
                var arguments = syntaxFactsService.GetArgumentsForInvocationExpression(invocation);
                if (arguments.Count >= 2)
                {
                    var firstArgumentExpression = syntaxFactsService.GetExpressionOfArgument(arguments[0]) as TLiteralExpressionSyntax;
                    if (firstArgumentExpression != null && syntaxFactsService.IsStringLiteral(firstArgumentExpression.GetFirstToken()))
                    {
                        invocationSymbol = semanticModel.GetSymbolInfo(invocation, cancellationToken).Symbol;
                        if (formatMethods.Contains(invocationSymbol))
                        {
                            break;
                        }
                    }
                }

                invocation = invocation.Parent?.FirstAncestorOrSelf <TInvocationExpressionSyntax>();
            }

            return(invocation != null);
        }
        private async Task <Document> CreateInterpolatedString(
            TInvocationExpressionSyntax invocation,
            Document document,
            ISyntaxFactsService syntaxFactsService,
            CancellationToken cancellationToken)
        {
            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            var arguments         = syntaxFactsService.GetArgumentsForInvocationExpression(invocation);
            var literalExpression = syntaxFactsService.GetExpressionOfArgument(arguments[0]) as TLiteralExpressionSyntax;
            var text                  = literalExpression.GetFirstToken().ToString();
            var syntaxGenerator       = document.Project.LanguageServices.GetService <SyntaxGenerator>();
            var expandedArguments     = GetExpandedArguments(semanticModel, arguments, syntaxGenerator, syntaxFactsService);
            var interpolatedString    = GetInterpolatedString(text);
            var newInterpolatedString = VisitArguments(expandedArguments, interpolatedString, syntaxFactsService);
            var root                  = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

            var newRoot = root.ReplaceNode(invocation, newInterpolatedString.WithTriviaFrom(invocation));

            return(document.WithSyntaxRoot(newRoot));
        }