[Refactoring] ConvertConcatenationToInterpolatedString: Support inlineing of other interpolated strings

[MaStr11]

Fixes #48900
Supersedes #49207

[MaStr11]

@CyrusNajmabadi Thanks for the review.

In my previous PR I added support for the removal of superfluous parentheses in Interpolation.Expression. I used the existing CanRemoveParentheses(SemanticModel semanticModel) extension method. So in case there are potentially removable expressions in the new InterploatedString, I requested a new sematicModel and removed the parentheses if possible:

https://github.com/MaStr11/roslyn/blob/b7928515a2f32da7b73803d9ffbe7f452a5eec1d/src/Features/CSharp/Portable/CodeRefactorings/ConvertStringConcatToInterpolated/CSharpConvertStringConcatToInterpolatedRefactoringProvider.cs#L104-L144

        private static async Task<Document> UpdateDocumentAsync(Document document, BinaryExpressionSyntax binaryExpression, ImmutableArray<ExpressionSyntax> concatParts, CancellationToken cancellationToken)
        {
            var interpolatedStringContent = ConvertConcatPartsToInterpolatedStringContent(concatParts);
            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            var editor = new SyntaxEditor(root, CSharpSyntaxGenerator.Instance);
            var interpolated = InterpolatedStringExpression(
                Token(SyntaxKind.InterpolatedStringStartToken),
                List(interpolatedStringContent));
            // expressions may have superfluous parenthesis after the conversion to an interpolated string:
            // "a" + (1 + 1) -> $"a{(1 + 1)}"
            // if there is any (InterpolationSyntax.Expression is ParenthesizedExpressionSyntax) we need to
            // recompile and check via parenthesized.CanRemoveParentheses(semanticModel) if it can be removed.
            var anyPotentiallyRemovableParenthesis = interpolated.Contents.Any(IsParenthesizedInterpolation);
            var annotation = new SyntaxAnnotation("InterpolatedStringExpressionWithPotentiallyRemovableParanthesisKind");
            if (anyPotentiallyRemovableParenthesis)
            {
                // annotate "interpolated" because we need to find it after the changes are applied
                interpolated = interpolated.WithAdditionalAnnotations(annotation);
            }
            editor.ReplaceNode(binaryExpression, interpolated);

            if (anyPotentiallyRemovableParenthesis)
            {
                // Take the changed document and go through interpolatedNode.Contents to check if any parenthesis can be removed.
                var newDocument = document.WithSyntaxRoot(editor.GetChangedRoot());
                var newRoot = await newDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                var interpolatedNode = (InterpolatedStringExpressionSyntax)newRoot.GetAnnotatedNodes(annotation).Single();
                var semanticModel = await newDocument.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
                editor = new SyntaxEditor(newRoot, CSharpSyntaxGenerator.Instance);
                foreach (var content in interpolatedNode.Contents.Where(IsParenthesizedInterpolation).Cast<InterpolationSyntax>())
                {
                    var parenthesized = (ParenthesizedExpressionSyntax)content.Expression;
                    if (parenthesized.CanRemoveParentheses(semanticModel))
                    {
                        editor.ReplaceNode(parenthesized, parenthesized.Expression);
                    }
                }
            }

            return document.WithSyntaxRoot(editor.GetChangedRoot());
        }

Test cases are here:
https://github.com/MaStr11/roslyn/blob/b7928515a2f32da7b73803d9ffbe7f452a5eec1d/src/EditorFeatures/CSharpTest/CodeActions/ConvertStringConcatToInterpolated/ConvertStringConcatToInterpolatedTests.cs#L197-L228

Do we want to reuse that approach here or not?

[CyrusNajmabadi]

Thanks!

[MaStr11]

@CyrusNajmabadi Sorry, but I haven't seen your LGTM before I pushed more commits. The commits are only minor clean-ups. I have one more question though: Should I add some logic to remove superfluous parenthesis? There are some approaches to do that. I implemented one with tests as described here: #49229 (comment). I could do this as part of this PR or a new one.

[CyrusNajmabadi]

I have one more question though: Should I add some logic to remove superfluous parenthesis?

In general, an easy way to do that is to just add the SimplifierAnnotation to the topmost node you're creating. We should then go through and clean up those parens. See if that works for you. Otherwise, i wouldn't bother doing more here (unless it was super easy).

[CyrusNajmabadi]

@CyrusNajmabadi Sorry, but I haven't seen your LGTM before I pushed more commits.

that's fine. i still review the later commits :)

[MaStr11]

SimplifierAnnotation to the topmost node

The Simplifier worked like a charm, but I needed to place it on each Expression of a newly generated InterploationSyntax (I also tried to place it on the final InterpolatedStringExpression but that didn't work).

[MaStr11]

@CyrusNajmabadi Tests are green now. I added the simplifier annotation to the expressions that gets capsulated in an Interpolation, but only if the expression is a ParenthesisExpression.

[aolszowka]

I am sorry I am new to this process, where does this go? How does this get mainlined?

[CyrusNajmabadi]

Thanks!