Fix string splitter multi-caret handling (#80883)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: CyrusNajmabadi <4564579+CyrusNajmabadi@users.noreply.github.com>
Co-authored-by: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>

Author: Copilot

src/EditorFeatures/CSharp/SplitStringLiteral/SplitStringLiteralCommandHandler.cs

@@ -6,6 +6,7 @@
 using System.ComponentModel.Composition;
 using System.Linq;
 using System.Threading;
+using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.CSharp.SplitStringLiteral;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
@@ -86,6 +87,13 @@ public bool ExecuteCommandWorker(ReturnKeyCommandArgs args, CancellationToken ca
         // The list of spans is traversed in reverse order so we do not have to
         // deal with updating later caret positions to account for the added space
         // from splitting at earlier caret positions.
+        // 
+        // However, we need to track the new caret positions in the original forward order
+        // for setting the multi-selection at the end. We use tracking points to automatically
+        // adjust positions as the buffer changes.
+        using var _ = PooledObjects.ArrayBuilder<ITrackingPoint>.GetInstance(spans.Count, fillWithValue: null!, out var trackingPoints);
+
+        var currentIndex = spans.Count - 1;
         foreach (var span in spans.Reverse())
         {
             using var transaction = CaretPreservingEditTransaction.TryCreate(
@@ -103,23 +111,35 @@ public bool ExecuteCommandWorker(ReturnKeyCommandArgs args, CancellationToken ca
             var newSnapshot = subjectBuffer.ApplyChanges(newDocument.GetChanges(parsedDocument));
             parsedDocument = newDocument;
 
-            // The buffer edit may have adjusted to position of the current caret but we might need a different location.
-            // Only adjust caret if it is the only one (no multi-caret support: https://github.com/dotnet/roslyn/issues/64812).
-            if (spans.Count == 1)
-            {
-                var newCaretPoint = textView.BufferGraph.MapUpToBuffer(
-                    new SnapshotPoint(newSnapshot, newPosition),
-                    PointTrackingMode.Negative,
-                    PositionAffinity.Predecessor,
-                    textView.TextBuffer);
-
-                if (newCaretPoint != null)
-                    textView.Caret.MoveTo(newCaretPoint.Value);
-            }
+            // Create a tracking point for the new caret position.
+            // Use Negative tracking mode so the caret stays before any text inserted at this position.
+            trackingPoints[currentIndex] = newSnapshot.CreateTrackingPoint(newPosition, PointTrackingMode.Negative);
 
             transaction?.Complete();
+            currentIndex--;
+        }
+
+        // Now set all the caret positions using the multi-selection broker.
+        // Get the position of each tracking point in the final snapshot.
+        var finalSnapshot = subjectBuffer.CurrentSnapshot;
+        using var finalCaretSpans = TemporaryArray<SnapshotSpan>.Empty;
+
+        foreach (var trackingPoint in trackingPoints)
+        {
+            var position = trackingPoint.GetPosition(finalSnapshot);
+            var newCaretPoint = textView.BufferGraph.MapUpToBuffer(
+                new SnapshotPoint(finalSnapshot, position),
+                PointTrackingMode.Negative,
+                PositionAffinity.Predecessor,
+                textView.TextBuffer);
+
+            if (newCaretPoint != null)
+                finalCaretSpans.AsRef().Add(new SnapshotSpan(newCaretPoint.Value, 0));
         }
 
+        if (finalCaretSpans.Count > 0)
+            textView.SetMultiSelection(finalCaretSpans.ToImmutableAndClear());
+
         return true;
 
         static bool LineContainsQuote(ITextSnapshotLine line, int caretPosition)

src/EditorFeatures/CSharpTest/SplitStringLiteral/SplitStringLiteralCommandHandlerTests.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.CodeAnalysis.Editor.CSharp.SplitStringLiteral;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
@@ -27,10 +28,9 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.SplitStringLiteral;
 public sealed class SplitStringLiteralCommandHandlerTests
 {
     /// <summary>
-    /// verifyUndo is needed because of https://github.com/dotnet/roslyn/issues/28033
-    /// Most tests will continue to verifyUndo, but select tests will skip it due to
-    /// this known test infrastructure issure. This bug does not represent a product
-    /// failure.
+    /// verifyUndo is needed because of https://github.com/dotnet/roslyn/issues/28033 Most tests will continue to
+    /// verifyUndo, but select tests will skip it due to this known test infrastructure issue. This bug does not
+    /// represent a product failure.
     /// </summary>
     private static void TestWorker(
         string inputMarkup,
@@ -113,14 +113,13 @@ private static void TestWorker(
     }
 
     /// <summary>
-    /// verifyUndo is needed because of https://github.com/dotnet/roslyn/issues/28033
-    /// Most tests will continue to verifyUndo, but select tests will skip it due to
-    /// this known test infrastructure issure. This bug does not represent a product
-    /// failure.
+    /// verifyUndo is needed because of https://github.com/dotnet/roslyn/issues/28033 Most tests will continue to
+    /// verifyUndo, but select tests will skip it due to this known test infrastructure issue. This bug does not
+    /// represent a product failure.
     /// </summary>
     private static void TestHandled(
-        string inputMarkup,
-        string expectedOutputMarkup,
+        [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string inputMarkup,
+        [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string expectedOutputMarkup,
         bool verifyUndo = true,
         IndentStyle indentStyle = IndentStyle.Smart,
         bool useTabs = false,
@@ -135,7 +134,8 @@ private static void TestHandled(
             verifyUndo, indentStyle, useTabs, endOfLine);
     }
 
-    private static void TestNotHandled(string inputMarkup)
+    private static void TestNotHandled(
+        [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string inputMarkup)
     {
         var notHandled = false;
         TestWorker(
@@ -1069,6 +1069,34 @@ void M()
             }
             """);
 
+    [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/64812")]
+    public void TestMultiCaretPositionsAreAllSet()
+    {
+        var inputMarkup = """
+            class C
+            {
+                void M()
+                {
+                    var v = "now is [||]the ti[||]me";
+                }
+            }
+            """;
+
+        var expectedMarkup = """
+            class C
+            {
+                void M()
+                {
+                    var v = "now is " +
+                        "[||]the ti" +
+                        "[||]me";
+                }
+            }
+            """;
+
+        TestHandled(inputMarkup, expectedMarkup);
+    }
+
     [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/40277")]
     public void TestInStringWithKeepTabsEnabled1()
         => TestHandled(