Merge pull request #30356 from rik-smeets/increase-span-convert-to-interpolated-string-refactoring

Increase available span for 'Convert to interpolated string' refactoring

src/EditorFeatures/CSharpTest/ConvertToInterpolatedString/ConvertConcatenationToInterpolatedStringTests.cs

@@ -539,6 +539,174 @@ void M()
     {
         var v = $@""{{{1}}}"";
     }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestMissingWithSelectionOnEntireToBeInterpolatedString()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        var v = [|""string"" + 1|];
+    }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestMissingWithSelectionOnPartOfToBeInterpolatedString()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        var v = [|""string"" + 1|] + ""string"";
+    }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestMissingWithSelectionExceedingToBeInterpolatedString()
+        {
+            await TestMissingInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        [|var v = ""string"" + 1|];
+    }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestWithCaretBeforeNonStringToken()
+        {
+            await TestInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        var v = [||]3 + ""string"" + 1 + ""string"";
+    }
+}",
+@"public class C
+{
+    void M()
+    {
+        var v = $""{3}string{1}string"";
+    }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestWithCaretAfterNonStringToken()
+        {
+            await TestInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        var v = 3[||] + ""string"" + 1 + ""string"";
+    }
+}",
+@"public class C
+{
+    void M()
+    {
+        var v = $""{3}string{1}string"";
+    }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestWithCaretBeforePlusToken()
+        {
+            await TestInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        var v = 3 [||]+ ""string"" + 1 + ""string"";
+    }
+}",
+@"public class C
+{
+    void M()
+    {
+        var v = $""{3}string{1}string"";
+    }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestWithCaretAfterPlusToken()
+        {
+            await TestInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        var v = 3 +[||] ""string"" + 1 + ""string"";
+    }
+}",
+@"public class C
+{
+    void M()
+    {
+        var v = $""{3}string{1}string"";
+    }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestWithCaretBeforeLastPlusToken()
+        {
+            await TestInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        var v = 3 + ""string"" + 1 [||]+ ""string"";
+    }
+}",
+@"public class C
+{
+    void M()
+    {
+        var v = $""{3}string{1}string"";
+    }
+}");
+        }
+
+        [WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)]
+        public async Task TestWithCaretAfterLastPlusToken()
+        {
+            await TestInRegularAndScriptAsync(
+@"public class C
+{
+    void M()
+    {
+        var v = 3 + ""string"" + 1 +[||] ""string"";
+    }
+}",
+@"public class C
+{
+    void M()
+    {
+        var v = $""{3}string{1}string"";
+    }
 }");
         }
     }

src/EditorFeatures/VisualBasicTest/ConvertToInterpolatedString/ConvertConcatenationToInterpolatedStringTests.vb

@@ -318,6 +318,150 @@ Public Class C
     Sub M()
         dim v = $""{{{1}}}""
     End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestMissingWithSelectionOnEntireToBeInterpolatedString() As Task
+            Await TestMissingInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        dim v = [|""string"" & 1|]
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestMissingWithSelectionOnPartOfToBeInterpolatedString() As Task
+            Await TestMissingInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        dim v = [|""string"" & 1|] & ""string""
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestMissingWithSelectionExceedingToBeInterpolatedString() As Task
+            Await TestMissingInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        [|dim v = ""string"" & 1|]
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestWithCaretBeforeNonStringToken() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        dim v = [||]3 & ""string"" & 1 & ""string""
+    End Sub
+End Class",
+"
+Public Class C
+    Sub M()
+        dim v = $""{3}string{1}string""
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestWithCaretAfterNonStringToken() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        dim v = 3[||] & ""string"" & 1 & ""string""
+    End Sub
+End Class",
+"
+Public Class C
+    Sub M()
+        dim v = $""{3}string{1}string""
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestWithCaretBeforeAmpersandToken() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        dim v = 3 [||]& ""string"" & 1 & ""string""
+    End Sub
+End Class",
+"
+Public Class C
+    Sub M()
+        dim v = $""{3}string{1}string""
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestWithCaretAfterAmpersandToken() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        dim v = 3 &[||] ""string"" & 1 & ""string""
+    End Sub
+End Class",
+"
+Public Class C
+    Sub M()
+        dim v = $""{3}string{1}string""
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestWithCaretBeforeLastAmpersandToken() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        dim v = 3 & ""string"" & 1 [||]& ""string""
+    End Sub
+End Class",
+"
+Public Class C
+    Sub M()
+        dim v = $""{3}string{1}string""
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(16981, "https://github.com/dotnet/roslyn/issues/16981")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertToInterpolatedString)>
+        Public Async Function TestWithCaretAfterLastAmpersandToken() As Task
+            Await TestInRegularAndScriptAsync(
+"
+Public Class C
+    Sub M()
+        dim v = 3 & ""string"" & 1 &[||] ""string""
+    End Sub
+End Class",
+"
+Public Class C
+    Sub M()
+        dim v = $""{3}string{1}string""
+    End Sub
 End Class")
         End Function
     End Class

src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs

@@ -22,8 +22,8 @@ internal abstract class AbstractConvertConcatenationToInterpolatedStringRefactor
     {
         public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
         {
-            // Currently only supported if there is no selection.  We could consider relaxing
-            // this if the selection is of a string concatenation expression.
+            // Currently only supported if there is no selection, to prevent possible confusion when
+            // selecting part of what would become an interpolated string
             if (context.Span.Length > 0)
             {
                 return;
@@ -36,28 +36,20 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var token = root.FindToken(position);
 
-            // Cursor has to at least be touching a string token.
             var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
-            if (!token.Span.IntersectsWith(position) ||
-                !syntaxFacts.IsStringLiteral(token))
-            {
-                return;
-            }
-
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
-            // The string literal has to at least be contained in a concatenation of some form.
-            // i.e.  "goo" + a      or     a + "goo".  However, those concats could be in larger
+            // The selected token has to at least be contained in a concatenation of some form.
+            // i.e.  "goo" + a      or    3 + 1 + "goo".  However, those concats could be in larger
             // concats as well.  Walk to the top of that entire chain.
-
-            var literalExpression = token.Parent;
-            var top = literalExpression;
+            var selectedExpression = token.Parent;
+            var top = selectedExpression;
             while (IsStringConcat(syntaxFacts, top.Parent, semanticModel, cancellationToken))
             {
                 top = top.Parent;
             }
 
-            if (top == literalExpression)
+            if (top == selectedExpression && !IsStringConcat(syntaxFacts, top, semanticModel, cancellationToken))
             {
                 // We weren't in a concatenation at all.
                 return;
@@ -78,9 +70,9 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
 
             // Make sure that all the string tokens we're concatenating are the same type
             // of string literal.  i.e. if we have an expression like: @" "" " + " \r\n "
-            // then we don't merge this.  We don't want to be munging differnet types of
+            // then we don't merge this.  We don't want to be munging different types of
             // escape sequences in these strings, so we only support combining the string
-            // tokens if they're all teh same type.
+            // tokens if they're all the same type.
             var firstStringToken = pieces.First(syntaxFacts.IsStringLiteralExpression).GetFirstToken();
             var isVerbatimStringLiteral = syntaxFacts.IsVerbatimStringLiteral(firstStringToken);
             if (pieces.Where(syntaxFacts.IsStringLiteralExpression).Any(