Fix speeling

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;
@@ -129,8 +129,8 @@ SyntaxKind.InterpolatedSingleLineRawStringStartToken or
     /// <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,
@@ -188,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/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);
         }
     }