Add support for smart string/copy paste when the destination is a raw string literal.

src/EditorFeatures/CSharp/StringCopyPaste/AbstractPasteProcessor.cs

@@ -85,10 +85,9 @@ internal abstract class AbstractPasteProcessor
         protected readonly string NewLine;
 
         /// <summary>
-        /// Users preferred indentation options.  Used when dealing with raw strings that we have to convert from
-        /// single-line to multiline.
+        /// Amount to indent content in a multi-line raw string literal.
         /// </summary>
-        protected readonly IndentationOptions IndentationOptions;
+        protected readonly string IndentationWhitespace;
 
         /// <summary>
         /// The set of <see cref="ITextChange"/>'s that produced <see cref="SnapshotAfterPaste"/> from <see
@@ -98,15 +97,15 @@ internal abstract class AbstractPasteProcessor
 
         protected AbstractPasteProcessor(
             string newLine,
-            IndentationOptions indentationOptions,
+            string indentationWhitespace,
             ITextSnapshot snapshotBeforePaste,
             ITextSnapshot snapshotAfterPaste,
             Document documentBeforePaste,
             Document documentAfterPaste,
             ExpressionSyntax stringExpressionBeforePaste)
         {
             NewLine = newLine;
-            IndentationOptions = indentationOptions;
+            IndentationWhitespace = indentationWhitespace;
 
             SnapshotBeforePaste = snapshotBeforePaste;
             SnapshotAfterPaste = snapshotAfterPaste;

src/EditorFeatures/CSharp/StringCopyPaste/StringCopyPasteCommandHandler.cs

@@ -56,19 +56,22 @@ internal partial class StringCopyPasteCommandHandler :
         private readonly ITextUndoHistoryRegistry _undoHistoryRegistry;
         private readonly IEditorOperationsFactoryService _editorOperationsFactoryService;
         private readonly IGlobalOptionService _globalOptions;
+        private readonly ITextBufferFactoryService2 _textBufferFactoryService;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public StringCopyPasteCommandHandler(
             IThreadingContext threadingContext,
             ITextUndoHistoryRegistry undoHistoryRegistry,
             IEditorOperationsFactoryService editorOperationsFactoryService,
-            IGlobalOptionService globalOptions)
+            IGlobalOptionService globalOptions,
+            ITextBufferFactoryService2 textBufferFactoryService)
         {
             _threadingContext = threadingContext;
             _undoHistoryRegistry = undoHistoryRegistry;
             _editorOperationsFactoryService = editorOperationsFactoryService;
             _globalOptions = globalOptions;
+            _textBufferFactoryService = textBufferFactoryService;
         }
 
         public string DisplayName => nameof(StringCopyPasteCommandHandler);
@@ -126,13 +129,7 @@ public void ExecuteCommand(PasteCommandArgs args, Action nextCommandHandler, Com
             if (stringExpressionBeforePaste == null)
                 return;
 
-            var pasteWasSuccessful = PasteWasSuccessful(
-                snapshotBeforePaste, snapshotAfterPaste, documentAfterPaste, stringExpressionBeforePaste, cancellationToken);
-
-            var newLine = textView.Options.GetNewLineCharacter();
-            var indentationOptions = documentBeforePaste.GetIndentationOptionsAsync(_globalOptions, cancellationToken).WaitAndGetResult(cancellationToken);
-
-            var textChanges = GetEdits(newLine, indentationOptions, cancellationToken);
+            var textChanges = GetEdits(cancellationToken);
 
             // If we didn't get any viable changes back, don't do anything.
             if (textChanges.IsDefaultOrEmpty)
@@ -180,23 +177,31 @@ public void ExecuteCommand(PasteCommandArgs args, Action nextCommandHandler, Com
             transaction.Complete();
             return;
 
-            ImmutableArray<TextChange> GetEdits(string newLine, IndentationOptions indentationOptions, CancellationToken cancellationToken)
+            ImmutableArray<TextChange> GetEdits(CancellationToken cancellationToken)
             {
+                var newLine = textView.Options.GetNewLineCharacter();
+                var indentationWhitespace = DetermineIndentationWhitespace(
+                    documentBeforePaste, snapshotBeforePaste.AsText(), stringExpressionBeforePaste, cancellationToken);
+
                 // See if this is a paste of the last copy that we heard about.
-                var edits = TryGetEditsFromKnownCopySource(newLine, indentationOptions, cancellationToken);
+                var edits = TryGetEditsFromKnownCopySource(newLine, indentationWhitespace, cancellationToken);
                 if (!edits.IsDefaultOrEmpty)
                     return edits;
 
-                // If not, then just go through teh fallback code path that applies more heuristics.
+                var pasteWasSuccessful = PasteWasSuccessful(
+                    snapshotBeforePaste, snapshotAfterPaste, documentAfterPaste, stringExpressionBeforePaste, cancellationToken);
+
+                // If not, then just go through the fallback code path that applies more heuristics.
                 var unknownPasteProcessor = new UnknownSourcePasteProcessor(
-                    newLine, indentationOptions,
+                    newLine, indentationWhitespace,
                     snapshotBeforePaste, snapshotAfterPaste,
                     documentBeforePaste, documentAfterPaste,
                     stringExpressionBeforePaste, pasteWasSuccessful);
                 return unknownPasteProcessor.GetEdits(cancellationToken);
             }
 
-            ImmutableArray<TextChange> TryGetEditsFromKnownCopySource(string newLine, IndentationOptions indentationOptions, CancellationToken cancellationToken)
+            ImmutableArray<TextChange> TryGetEditsFromKnownCopySource(
+                string newLine, string indentationWhitespace, CancellationToken cancellationToken)
             {
                 // For simplicity, we only support smart copy/paste when we are pasting into a single contiguous region.
                 if (selectionsBeforePaste.Count != 1)
@@ -212,16 +217,41 @@ ImmutableArray<TextChange> TryGetEditsFromKnownCopySource(string newLine, Indent
                     return default;
 
                 var knownProcessor = new KnownSourcePasteProcessor(
-                    newLine, indentationOptions,
+                    newLine, indentationWhitespace,
                     snapshotBeforePaste, snapshotAfterPaste,
                     documentBeforePaste, documentAfterPaste,
                     stringExpressionBeforePaste,
-                    selectionsBeforePaste[0],
-                    copyPasteData);
+                    selectionsBeforePaste[0].Span.ToTextSpan(),
+                    copyPasteData, _textBufferFactoryService);
                 return knownProcessor.GetEdits(cancellationToken);
             }
         }
 
+        private string DetermineIndentationWhitespace(
+            Document documentBeforePaste,
+            SourceText textBeforePaste,
+            ExpressionSyntax stringExpressionBeforePaste,
+            CancellationToken cancellationToken)
+        {
+            // Only raw strings care about indentation.  Don't bother computing if we don't need it.
+            if (!IsAnyRawStringExpression(stringExpressionBeforePaste))
+                return "";
+
+            if (IsAnyMultiLineRawStringExpression(stringExpressionBeforePaste))
+            {
+                // already have a multi-line raw string.  The indentation of it's end delimiter is the indentation all
+                // lines within it should have.
+                var lastLine = textBeforePaste.Lines.GetLineFromPosition(stringExpressionBeforePaste.Span.End);
+                var quotePosition = lastLine.GetFirstNonWhitespacePosition()!.Value;
+                return textBeforePaste.ToString(TextSpan.FromBounds(lastLine.Span.Start, quotePosition));
+            }
+
+            // Otherwise, we have a single-line raw string.  Determine the default indentation desired here.
+            // We'll use that if we have to convert this single-line raw string to a multi-line one.
+            var indentationOptions = documentBeforePaste.GetIndentationOptionsAsync(_globalOptions, cancellationToken).WaitAndGetResult(cancellationToken);
+            return stringExpressionBeforePaste.GetFirstToken().GetPreferredIndentation(documentBeforePaste, indentationOptions, cancellationToken);
+        }
+
         /// <summary>
         /// Returns true if the paste resulted in legal code for the string literal.  The string literal is
         /// considered legal if it has the same span as the original string (adjusted as per the edit) and that

src/EditorFeatures/CSharp/StringCopyPaste/UnknownSourcePasteProcessor.cs

@@ -37,14 +37,14 @@ internal sealed class UnknownSourcePasteProcessor : AbstractPasteProcessor
 
         public UnknownSourcePasteProcessor(
             string newLine,
-            IndentationOptions indentationOptions,
+            string indentationWhitespace,
             ITextSnapshot snapshotBeforePaste,
             ITextSnapshot snapshotAfterPaste,
             Document documentBeforePaste,
             Document documentAfterPaste,
             ExpressionSyntax stringExpressionBeforePaste,
             bool pasteWasSuccessful)
-            : base(newLine, indentationOptions, snapshotBeforePaste, snapshotAfterPaste, documentBeforePaste, documentAfterPaste, stringExpressionBeforePaste)
+            : base(newLine, indentationWhitespace, snapshotBeforePaste, snapshotAfterPaste, documentBeforePaste, documentAfterPaste, stringExpressionBeforePaste)
         {
             _pasteWasSuccessful = pasteWasSuccessful;
         }
@@ -132,7 +132,7 @@ private ImmutableArray<TextChange> GetEditsForRawString(CancellationToken cancel
             if (dollarSignsToAdd != null)
                 edits.Add(new TextChange(new TextSpan(StringExpressionBeforePaste.Span.Start, 0), dollarSignsToAdd));
 
-            // Then any quotes to your starting delimiter
+            // Then any quotes to the start delimiter.
             if (quotesToAdd != null)
                 edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.ContentSpans.First().Start, 0), quotesToAdd));
 
@@ -143,7 +143,7 @@ private ImmutableArray<TextChange> GetEditsForRawString(CancellationToken cancel
             else
                 AdjustWhitespaceAndAddTextChangesForSingleLineRawStringLiteral(edits, cancellationToken);
 
-            // Then add any extra end quotes needed.
+            // Then  any extra quotes to the end delimiter.
             if (quotesToAdd != null)
                 edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.EndDelimiterSpanWithoutSuffix.End, 0), quotesToAdd));
 
@@ -172,13 +172,11 @@ private void AdjustWhitespaceAndAddTextChangesForSingleLineRawStringLiteral(
 
             var mustBeMultiLine = RawContentMustBeMultiLine(TextAfterPaste, TextContentsSpansAfterPaste);
 
-            var indentationWhitespace = StringExpressionBeforePaste.GetFirstToken().GetPreferredIndentation(DocumentBeforePaste, IndentationOptions, cancellationToken);
-
             using var _ = PooledStringBuilder.GetInstance(out var buffer);
 
             // A newline and the indentation to start with.
             if (mustBeMultiLine)
-                edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.StartDelimiterSpan.End, 0), NewLine + indentationWhitespace));
+                edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.StartDelimiterSpan.End, 0), NewLine + IndentationWhitespace));
 
             SourceText? textOfCurrentChange = null;
             var commonIndentationPrefix = GetCommonIndentationPrefix(Changes) ?? "";
@@ -213,7 +211,7 @@ private void AdjustWhitespaceAndAddTextChangesForSingleLineRawStringLiteral(
 
                     // if we ended with a newline, make sure the next line is indented enough.
                     if (HasNewLine(currentChangeLine))
-                        buffer.Append(indentationWhitespace);
+                        buffer.Append(IndentationWhitespace);
                 }
 
                 edits.Add(new TextChange(change.OldSpan.ToTextSpan(), buffer.ToString()));
@@ -222,7 +220,7 @@ private void AdjustWhitespaceAndAddTextChangesForSingleLineRawStringLiteral(
             // if the last change ended at the closing delimiter *and* ended with a newline, then we don't need to add a
             // final newline-space at the end because we will have already done that.
             if (mustBeMultiLine && !LastPastedLineAddedNewLine())
-                edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.EndDelimiterSpan.Start, 0), NewLine + indentationWhitespace));
+                edits.Add(new TextChange(new TextSpan(StringExpressionBeforePasteInfo.EndDelimiterSpan.Start, 0), NewLine + IndentationWhitespace));
 
             return;