Improve raw string completion (#77742)

Fixes #77724.

Author: CyrusNajmabadi

src/EditorFeatures/CSharp/CompleteStatement/CompleteStatementCommandHandler.cs

@@ -172,7 +172,7 @@ private static bool TryGetStartingNode(
 
         startingNode = tokenOnLeft.GetRequiredParent();
 
-        // If the caret is before an opening delimiter or after a closing delimeter,
+        // If the caret is before an opening delimiter or after a closing delimiter,
         // start analysis with node outside of delimiters.
         //
         // Examples, 

src/EditorFeatures/CSharp/RawStringLiteral/RawStringLiteralCommandHandler_TypeChar.cs

@@ -53,7 +53,7 @@ private bool ExecuteCommandWorker(TypeCharCommandArgs args, Action nextCommandHa
         var textChangeOpt =
             TryGenerateInitialEmptyRawString(caret.Value, cancellationToken) ??
             TryGrowInitialEmptyRawString(caret.Value, cancellationToken) ??
-            TryGrowRawStringDelimeters(caret.Value, cancellationToken);
+            TryGrowRawStringDelimiters(caret.Value, cancellationToken);
 
         if (textChangeOpt is not TextChange textChange)
             return false;
@@ -115,17 +115,22 @@ private bool ExecuteCommandWorker(TypeCharCommandArgs args, Action nextCommandHa
         if (token.SpanStart != start)
             return null;
 
-        if (token.Kind() is not (SyntaxKind.StringLiteralToken or SyntaxKind.InterpolatedStringStartToken or SyntaxKind.InterpolatedSingleLineRawStringStartToken))
+        if (token.Kind() is not (SyntaxKind.StringLiteralToken or
+                                 SyntaxKind.InterpolatedStringStartToken or
+                                 SyntaxKind.InterpolatedSingleLineRawStringStartToken or
+                                 SyntaxKind.InterpolatedMultiLineRawStringStartToken))
+        {
             return null;
+        }
 
         return new TextChange(new TextSpan(position + 1, 0), "\"\"\"");
     }
 
     /// <summary>
     /// When typing <c>"</c> given a raw string like <c>"""$$"""</c> (or a similar multiline form), then update the
     /// text to be: <c>""""$$""""</c>.  i.e. grow both the start and end delimiters to keep the string properly
-    /// balanced.  This differs from TryGrowRawStringDelimeters in that the language will consider that initial
-    /// <c>""""""</c> text to be a single delimeter, while we want to treat it as two.
+    /// balanced.  This differs from TryGrowRawStringDelimiters in that the language will consider that initial
+    /// <c>""""""</c> text to be a single delimiter, while we want to treat it as two.
     /// </summary>
     private static TextChange? TryGrowInitialEmptyRawString(
         SnapshotPoint caret,
@@ -183,15 +188,15 @@ SyntaxKind.InterpolatedSingleLineRawStringStartToken or
     /// update the text to be: <c>"""" goo bar """"</c>.  i.e. grow both the start and end delimiters to keep the
     /// string properly balanced.
     /// </summary>
-    private static TextChange? TryGrowRawStringDelimeters(
+    private static TextChange? TryGrowRawStringDelimiters(
         SnapshotPoint caret,
         CancellationToken cancellationToken)
     {
         var snapshot = caret.Snapshot;
         var position = caret.Position;
 
         // if we have """$$"   then typing `"` here should not grow the start/end quotes.  we only want to grow them
-        // if the user is at the end of the start delimeter.
+        // if the user is at the end of the start delimiter.
         if (position < snapshot.Length && snapshot[position] == '"')
             return null;
 

src/EditorFeatures/CSharpTest/RawStringLiteral/RawStringLiteralCommandHandlerTests.cs

@@ -616,6 +616,27 @@ public void TestGenerateWithInterpolatedString_TwoDollarSigns()
             """", withSpansOnly: true);
     }
 
+    [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/77724")]
+    public void TestGenerateWithInterpolatedString_TwoDollarSigns_InLocalFunction()
+    {
+        using var testState = RawStringLiteralTestState.CreateTestState(
+            """
+            void M()
+            {
+                var v = $$""[||]
+            }
+            """, withSpansOnly: true);
+
+        testState.SendTypeChar('"');
+        testState.AssertCodeIs(
+            """"
+            void M()
+            {
+                var v = $$"""[||]"""
+            }
+            """", withSpansOnly: true);
+    }
+
     [WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/66538")]
     public void TestGenerateWithInterpolatedString_TwoDollarSigns_FourthDoubleQuote()
     {

src/Features/CSharp/Portable/NavigationBar/CSharpNavigationBarItemService.cs

@@ -21,7 +21,9 @@
 namespace Microsoft.CodeAnalysis.CSharp.NavigationBar;
 
 [ExportLanguageService(typeof(INavigationBarItemService), LanguageNames.CSharp), Shared]
-internal class CSharpNavigationBarItemService : AbstractNavigationBarItemService
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class CSharpNavigationBarItemService() : AbstractNavigationBarItemService
 {
     private static readonly SymbolDisplayFormat s_typeFormat =
         SymbolDisplayFormat.CSharpErrorMessageFormat.AddGenericsOptions(SymbolDisplayGenericsOptions.IncludeVariance);
@@ -39,12 +41,6 @@ internal class CSharpNavigationBarItemService : AbstractNavigationBarItemService
                                   SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral |
                                   SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
 
-    [ImportingConstructor]
-    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-    public CSharpNavigationBarItemService()
-    {
-    }
-
     protected override async Task<ImmutableArray<RoslynNavigationBarItem>> GetItemsInCurrentProcessAsync(
         Document document, bool supportsCodeGeneration, CancellationToken cancellationToken)
     {

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/SyntaxTreeExtensions.cs

@@ -349,32 +349,32 @@ SyntaxKind.Utf8SingleLineRawStringLiteralToken or
         if (kind is SyntaxKind.SingleLineRawStringLiteralToken or SyntaxKind.MultiLineRawStringLiteralToken)
         {
             var sourceText = token.SyntaxTree!.GetText(cancellationToken);
-            var startDelimeterLength = 0;
-            var endDelimeterLength = 0;
+            var startDelimiterLength = 0;
+            var endDelimiterLength = 0;
             for (int i = token.SpanStart, n = token.Span.End; i < n; i++)
             {
                 if (sourceText[i] != '"')
                     break;
 
-                startDelimeterLength++;
+                startDelimiterLength++;
             }
 
             for (int i = token.Span.End - 1, n = token.Span.Start; i >= n; i--)
             {
                 if (sourceText[i] != '"')
                     break;
 
-                endDelimeterLength++;
+                endDelimiterLength++;
             }
 
-            return token.Span.Length == startDelimeterLength ||
-                (token.Span.Length > startDelimeterLength && endDelimeterLength < startDelimeterLength);
+            return token.Span.Length == startDelimiterLength ||
+                (token.Span.Length > startDelimiterLength && endDelimiterLength < startDelimiterLength);
         }
         else
         {
-            var startDelimeterLength = token.IsVerbatimStringLiteral() ? 2 : 1;
-            return token.Span.Length == startDelimeterLength ||
-                (token.Span.Length > startDelimeterLength && token.Text[^1] != lastChar);
+            var startDelimiterLength = token.IsVerbatimStringLiteral() ? 2 : 1;
+            return token.Span.Length == startDelimiterLength ||
+                (token.Span.Length > startDelimiterLength && token.Text[^1] != lastChar);
         }
     }